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_numeric`
54 # assert "-10".to_json_value.to_i == -10
55 # assert "123".to_json_value.to_i == 123
56 # assert "123.456".to_json_value.to_i == 123
60 assert value
isa Numeric
64 # Is this value a float?
66 # assert "0.0".to_json_value.is_float
67 # assert "123.456".to_json_value.is_float
68 # assert not "123".to_json_value.is_float
69 fun is_float
: Bool do return value
isa Float
71 # Get this value as a `Float`
73 # require: `self.is_numeric`
75 # assert "0.0".to_json_value.to_f == 0.0
76 # assert "123.456".to_json_value.to_f == 123.456
77 # assert "123".to_json_value.to_f == 123.0
81 assert value
isa Numeric
85 # Is the value numeric?
87 # assert "1.234".to_json_value.is_numeric
88 # assert "1234".to_json_value.is_numeric
89 # assert not "\"str\"".to_json_value.is_numeric
90 # assert not "1.2.3.4".to_json_value.is_numeric
91 fun is_numeric
: Bool do return is_int
or is_float
93 # Get this value as a `Numeric`
95 # require: `self.is_numeric`
97 # assert "1.234".to_json_value.to_numeric == 1.234
98 # assert "1234".to_json_value.to_numeric == 1234
99 fun to_numeric
: Numeric
101 if is_int
then return to_i
105 # Is this value a boolean?
107 # assert "true".to_json_value.is_bool
108 # assert "false".to_json_value.is_bool
109 fun is_bool
: Bool do return value
isa Bool
111 # Get this value as a `Bool`
113 # require: `self.is_bool`
115 # assert "true".to_json_value.to_bool
116 # assert not "false".to_json_value.to_bool
117 fun to_bool
: Bool do return value
.as(Bool)
119 # Is this value a string?
121 # assert "\"str\"".to_json_value.is_string
122 # assert not "123".to_json_value.is_string
123 fun is_string
: Bool do return value
isa String
125 # Get this value as a `String`
127 # If value is null, return "null", otherwise returns `value.to_s`. It is practical
128 # on most types, except maps which does not have a custom `to_s`.
130 # assert "\"str\"".to_json_value.to_s == "str"
131 # assert "123".to_json_value.to_s == "123"
132 # assert "true".to_json_value.to_s == "true"
133 # assert "[1, 2, 3]".to_json_value.to_s == "123"
134 redef fun to_s
: String
136 if value
== null then return "null"
142 # Is this value a Json object (a map)?
144 # assert """{"a": 123}""".to_json_value.is_map
145 # assert not "123".to_json_value.is_map
146 fun is_map
: Bool do return value
isa MapRead[String, nullable Object]
148 # Get this value as a `Map[String, JsonValue]`
150 # require: `self.is_map`
151 fun to_map
: Map[String, JsonValue] do
153 assert value
isa MapRead[String, nullable Object]
155 var map
= new HashMap[String, JsonValue]
156 for k
, v
in value
do map
[k
] = new JsonValue(v
)
162 # Is this value an array?
164 # assert "[]".to_json_value.is_array
165 # assert "[1, 2, 3, 4, 5]".to_json_value.is_array
166 # assert "[null, true, false, 0.0, 1, \"str\"]".to_json_value.is_array
167 # assert """["a", "b", "c"]""".to_json_value.is_array
168 fun is_array
: Bool do return value
isa SequenceRead[nullable Object]
170 # Get this value as an `Array[JsonValue]`
172 # require: `self.is_array`
174 # assert """["a", "b", "c"]""".to_json_value.to_a.join(", ") == "a, b, c"
175 fun to_a
: Array[JsonValue]
178 assert value
isa SequenceRead[nullable Object]
180 var a
= new Array[JsonValue]
181 for e
in value
do a
.add
(new JsonValue(e
))
187 # Is this value an error?
189 # assert "[]".to_json_value[0].is_error
190 # assert "[".to_json_value.is_error
191 # assert not "[]".to_json_value.is_error
192 fun is_error
: Bool do return value
isa Error
194 # Get this value as a `Error`.
196 # require: `self.is_error`
197 fun to_error
: Error do return value
.as(Error)
201 # Is this value a parse error?
203 # assert "[".to_json_value.is_parse_error
204 # assert not "[]".to_json_value.is_parse_error
205 fun is_parse_error
: Bool do return value
isa JsonParseError
207 # Get this value as a `JsonParseError`.
209 # require: `self.is_parse_error`
210 fun to_parse_error
: JsonParseError do return value
.as(JsonParseError)
214 # Iterator over the values of the array `self`
216 # require: `self.is_array`
218 # var a = new Array[String]
219 # for e in """["a", "b", "c"]""".to_json_value do a.add(e.to_s)
223 fun iterator
: Iterator[JsonValue] do return to_a
.iterator
225 # Get value at index `key` on the array or map `self`
227 # require: `self.is_array or self.is_map`
228 # require: `self.is_array implies key isa Int`
230 # assert """{"a": 123}""".to_json_value["a"].to_i == 123
231 # assert """{"123": "a"}""".to_json_value[123].to_s == "a"
232 # assert """{"John Smith": 1980}""".to_json_value[["John ", "Smith"]].to_i == 1980
233 # assert """{"a": 123}""".to_json_value["b"].is_error
235 # assert """["a", "b", "c"]""".to_json_value[0].to_s == "a"
236 # assert """["a", "b", "c"]""".to_json_value[3].is_error
237 fun [](key
: Object): JsonValue do
239 var result
: nullable Object
242 else if value
isa MapRead[String, nullable Object] then
244 if value
.has_key
(key
) then
247 result
= new JsonKeyError("Key `{key}` not found.", self, key
)
249 else if value
isa SequenceRead[nullable Object] then
251 if key
< value
.length
and key
>= 0 then
254 result
= new JsonKeyError("Index `{key}` out of bounds.",
258 result
= new JsonKeyError("Invalid key type. Expecting `Int`. Got `{key.class_name}`.",
262 result
= new JsonKeyError("Invalid `[]` access on a `{json_type}` JsonValue.",
265 return new JsonValue(result
)
268 # Advanced query to get a value within the map `self` or it's children.
270 # A query is composed of the keys to each map seperated by '.'.
272 # require: `self.is_map`
274 # assert """{"a": {"t": true, "f": false}}""".to_json_value.get("a").is_map
275 # assert """{"a": {"t": true, "f": false}}""".to_json_value.get("a.t").to_bool
276 # assert not """{"a": {"t": true, "f": false}}""".to_json_value.get("a.f").to_bool
277 # assert """{"a": {"t": true, "f": false}}""".to_json_value.get("a.t.t").is_error
278 # assert """{"a": {"b": {"c": {"d": 123}}}}""".to_json_value.get("a.b.c.d").to_i == 123
279 # assert """{"a": {"b": {"c": {"d": 123}}}}""".to_json_value.get("a.z.c.d").is_error
280 fun get
(query
: String): JsonValue do
281 var keys
= query
.split
(".")
283 if is_error
then return self
284 for i
in [0..keys
.length
[ do
286 if value
isa MapRead[String, nullable Object] then
287 if value
.has_key
(key
) then
290 var sub_query
= sub_query_to_s
(keys
, i
)
291 var e
= new JsonKeyError("Key `{key}` not found.",
293 return new JsonValue(e
)
296 var sub_query
= sub_query_to_s
(keys
, i
)
297 var val_type
= (new JsonValue(value
)).json_type
298 var e
= new JsonKeyError("Value at `{sub_query}` is not a map. Got type `{val_type}`",
300 return new JsonValue(e
)
303 return new JsonValue(value
)
306 # Concatenate all keys up to `last` for debugging purposes.
308 # Note: This method deletes elements in `keys`.
309 private fun sub_query_to_s
(keys
: Array[String], last
: Int): String do
311 for j
in [last
..keys
.length
[ do keys
.pop
312 return keys
.join
(".")
315 # Return a human-readable description of the type.
317 # For debugging purpose only.
318 fun json_type
: String do
319 if is_array
then return "array"
320 if is_bool
then return "bool"
321 if is_float
then return "float"
322 if is_int
then return "int"
323 if is_null
then return "null"
324 if is_map
then return "map"
325 if is_string
then return "string"
326 if is_parse_error
then return "parse_error"
327 if is_error
then return "error"
332 # Keyed access failed.
336 # The value on which the access was requested.
337 var json_value
: JsonValue
341 # In the case of `JsonValue.get`, the sub-query that failed.
346 # Parse `self` to obtain a `JsonValue`
347 fun to_json_value
: JsonValue do
348 var value
= parse_json
349 return new JsonValue(value
)