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 == "[1,2,3]"
135 if value
== null then return "null"
141 # Is this value a Json object (a map)?
143 # assert """{"a": 123}""".to_json_value.is_map
144 # assert not "123".to_json_value.is_map
145 fun is_map
: Bool do return value
isa MapRead[String, nullable Object]
147 # Get this value as a `Map[String, JsonValue]`
149 # require: `self.is_map`
150 fun to_map
: Map[String, JsonValue] do
152 assert value
isa MapRead[String, nullable Object]
154 var map
= new HashMap[String, JsonValue]
155 for k
, v
in value
do map
[k
] = new JsonValue(v
)
161 # Is this value an array?
163 # assert "[]".to_json_value.is_array
164 # assert "[1, 2, 3, 4, 5]".to_json_value.is_array
165 # assert "[null, true, false, 0.0, 1, \"str\"]".to_json_value.is_array
166 # assert """["a", "b", "c"]""".to_json_value.is_array
167 fun is_array
: Bool do return value
isa SequenceRead[nullable Object]
169 # Get this value as an `Array[JsonValue]`
171 # require: `self.is_array`
173 # assert """["a", "b", "c"]""".to_json_value.to_a.join(", ") == "a, b, c"
174 fun to_a
: Array[JsonValue]
177 assert value
isa SequenceRead[nullable Object]
179 var a
= new Array[JsonValue]
180 for e
in value
do a
.add
(new JsonValue(e
))
186 # Is this value an error?
188 # assert "[]".to_json_value[0].is_error
189 # assert "[".to_json_value.is_error
190 # assert not "[]".to_json_value.is_error
191 fun is_error
: Bool do return value
isa Error
193 # Get this value as a `Error`.
195 # require: `self.is_error`
196 fun to_error
: Error do return value
.as(Error)
200 # Is this value a parse error?
202 # assert "[".to_json_value.is_parse_error
203 # assert not "[]".to_json_value.is_parse_error
204 fun is_parse_error
: Bool do return value
isa JsonParseError
206 # Get this value as a `JsonParseError`.
208 # require: `self.is_parse_error`
209 fun to_parse_error
: JsonParseError do return value
.as(JsonParseError)
213 # Iterator over the values of the array `self`
215 # require: `self.is_array`
217 # var a = new Array[String]
218 # for e in """["a", "b", "c"]""".to_json_value do a.add(e.to_s)
222 fun iterator
: Iterator[JsonValue] do return to_a
.iterator
224 # Get value at index `key` on the array or map `self`
226 # require: `self.is_array or self.is_map`
227 # require: `self.is_array implies key isa Int`
229 # assert """{"a": 123}""".to_json_value["a"].to_i == 123
230 # assert """{"123": "a"}""".to_json_value[123].to_s == "a"
231 # assert """{"John Smith": 1980}""".to_json_value["John Smith"].to_i == 1980
232 # assert """{"a": 123}""".to_json_value["b"].is_error
234 # assert """["a", "b", "c"]""".to_json_value[0].to_s == "a"
235 # assert """["a", "b", "c"]""".to_json_value[3].is_error
236 fun [](key
: Object): JsonValue do
238 var result
: nullable Object
241 else if value
isa MapRead[String, nullable Object] then
243 if value
.has_key
(key
) then
246 result
= new JsonKeyError("Key `{key}` not found.", self, key
)
248 else if value
isa SequenceRead[nullable Object] then
250 if key
< value
.length
and key
>= 0 then
253 result
= new JsonKeyError("Index `{key}` out of bounds.",
257 result
= new JsonKeyError("Invalid key type. Expecting `Int`. Got `{key.class_name}`.",
261 result
= new JsonKeyError("Invalid `[]` access on a `{json_type}` JsonValue.",
264 return new JsonValue(result
)
267 # Advanced query to get a value within the map `self` or it's children.
269 # A query is composed of the keys to each map seperated by '.'.
271 # require: `self.is_map`
273 # assert """{"a": {"t": true, "f": false}}""".to_json_value.get("a").is_map
274 # assert """{"a": {"t": true, "f": false}}""".to_json_value.get("a.t").to_bool
275 # assert not """{"a": {"t": true, "f": false}}""".to_json_value.get("a.f").to_bool
276 # assert """{"a": {"t": true, "f": false}}""".to_json_value.get("a.t.t").is_error
277 # assert """{"a": {"b": {"c": {"d": 123}}}}""".to_json_value.get("a.b.c.d").to_i == 123
278 # assert """{"a": {"b": {"c": {"d": 123}}}}""".to_json_value.get("a.z.c.d").is_error
279 fun get
(query
: String): JsonValue do
280 var keys
= query
.split
(".")
282 if is_error
then return self
283 for i
in [0..keys
.length
[ do
285 if value
isa MapRead[String, nullable Object] then
286 if value
.has_key
(key
) then
289 var sub_query
= sub_query_to_s
(keys
, i
)
290 var e
= new JsonKeyError("Key `{key}` not found.",
292 return new JsonValue(e
)
295 var sub_query
= sub_query_to_s
(keys
, i
)
296 var val_type
= (new JsonValue(value
)).json_type
297 var e
= new JsonKeyError("Value at `{sub_query}` is not a map. Got type `{val_type}`",
299 return new JsonValue(e
)
302 return new JsonValue(value
)
305 # Concatenate all keys up to `last` for debugging purposes.
307 # Note: This method deletes elements in `keys`.
308 private fun sub_query_to_s
(keys
: Array[String], last
: Int): String do
310 for j
in [last
..keys
.length
[ do keys
.pop
311 return keys
.join
(".")
314 # Return a human-readable description of the type.
316 # For debugging purpose only.
317 fun json_type
: String do
318 if is_array
then return "array"
319 if is_bool
then return "bool"
320 if is_float
then return "float"
321 if is_int
then return "int"
322 if is_null
then return "null"
323 if is_map
then return "map"
324 if is_string
then return "string"
325 if is_parse_error
then return "parse_error"
326 if is_error
then return "error"
331 # Keyed access failed.
335 # The value on which the access was requested.
336 var json_value
: JsonValue
340 # In the case of `JsonValue.get`, the sub-query that failed.
345 # Parse `self` to obtain a `JsonValue`
346 fun to_json_value
: JsonValue do
347 var value
= parse_json
348 return new JsonValue(value
)