lib/json/dynamic.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
   4 #
   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
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  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.
  16
  17 # Dynamic interface to read JSON strings.
  18 #
  19 # `String::to_json_value` returns a `JsonValue` which can be queried
  20 # to get the underlying JSON data.
  21 module dynamic
  22
  23 import error
  24 private import static
  25
  26 # Wraps a JSON value.
  27 #
  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).
  30 #
  31 # Use `String::to_json_value` to get a `JsonValue` from a string.
  32 class JsonValue
  33
  34         # The wrapped JSON value.
  35         var value: nullable Object
  36
  37         # Is this value null?
  38         #
  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
  42
  43         # Is this value an integer?
  44         #
  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
  49
  50         # Get this value as a `Int`
  51         #
  52         # require: `self.is_numeric`
  53         #
  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
  57         fun to_i: Int
  58         do
  59                 var value = value
  60                 assert value isa Numeric
  61                 return value.to_i
  62         end
  63
  64         # Is this value a float?
  65         #
  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
  70
  71         # Get this value as a `Float`
  72         #
  73         # require: `self.is_numeric`
  74         #
  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
  78         fun to_f: Float
  79         do
  80                 var value = value
  81                 assert value isa Numeric
  82                 return value.to_f
  83         end
  84
  85         # Is the value numeric?
  86         #
  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
  92
  93         # Get this value as a `Numeric`
  94         #
  95         # require: `self.is_numeric`
  96         #
  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
 100         do
 101                 if is_int then return to_i
 102                 return to_f
 103         end
 104
 105         # Is this value a boolean?
 106         #
 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
 110
 111         # Get this value as a `Bool`
 112         #
 113         # require: `self.is_bool`
 114         #
 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)
 118
 119         # Is this value a string?
 120         #
 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
 124
 125         # Get this value as a `String`
 126         #
 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`.
 129         #
 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]"
 134         redef fun to_s do
 135                 if value == null then return "null"
 136                 return value.to_s
 137         end
 138
 139         ### Objects
 140
 141         # Is this value a Json object (a map)?
 142         #
 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]
 146
 147         # Get this value as a `Map[String, JsonValue]`
 148         #
 149         # require: `self.is_map`
 150         fun to_map: Map[String, JsonValue] do
 151                 var value = value
 152                 assert value isa MapRead[String, nullable Object]
 153
 154                 var map = new HashMap[String, JsonValue]
 155                 for k, v in value do map[k] = new JsonValue(v)
 156                 return map
 157         end
 158
 159         ### Arrays
 160
 161         # Is this value an array?
 162         #
 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]
 168
 169         # Get this value as an `Array[JsonValue]`
 170         #
 171         # require: `self.is_array`
 172         #
 173         #     assert """["a", "b", "c"]""".to_json_value.to_a.join(", ") == "a, b, c"
 174         fun to_a: Array[JsonValue]
 175         do
 176                 var value = value
 177                 assert value isa SequenceRead[nullable Object]
 178
 179                 var a = new Array[JsonValue]
 180                 for e in value do a.add(new JsonValue(e))
 181                 return a
 182         end
 183
 184         ### Error
 185
 186         # Is this value an error?
 187         #
 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
 192
 193         # Get this value as a `Error`.
 194         #
 195         # require: `self.is_error`
 196         fun to_error: Error do return value.as(Error)
 197
 198         ### JsonParseError
 199
 200         # Is this value a parse error?
 201         #
 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
 205
 206         # Get this value as a `JsonParseError`.
 207         #
 208         # require: `self.is_parse_error`
 209         fun to_parse_error: JsonParseError do return value.as(JsonParseError)
 210
 211         ### Children access
 212
 213         # Iterator over the values of the array `self`
 214         #
 215         # require: `self.is_array`
 216         #
 217         #     var a = new Array[String]
 218         #     for e in """["a", "b", "c"]""".to_json_value do a.add(e.to_s)
 219         #     assert a[0] == "a"
 220         #     assert a[1] == "b"
 221         #     assert a[2] == "c"
 222         fun iterator: Iterator[JsonValue] do return to_a.iterator
 223
 224         # Get value at index `key` on the array or map `self`
 225         #
 226         # require: `self.is_array or self.is_map`
 227         # require: `self.is_array implies key isa Int`
 228         #
 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
 233         #
 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
 237                 var value = value
 238                 var result: nullable Object
 239                 if is_error then
 240                         return self
 241                 else if value isa MapRead[String, nullable Object] then
 242                         key = key.to_s
 243                         if value.has_key(key) then
 244                                 result = value[key]
 245                         else
 246                                 result = new JsonKeyError("Key `{key}` not found.", self, key)
 247                         end
 248                 else if value isa SequenceRead[nullable Object] then
 249                         if key isa Int then
 250                                 if key < value.length and key >= 0 then
 251                                         result = value[key]
 252                                 else
 253                                         result = new JsonKeyError("Index `{key}` out of bounds.",
 254                                                         self, key)
 255                                 end
 256                         else
 257                                 result = new JsonKeyError("Invalid key type. Expecting `Int`. Got `{key.class_name}`.",
 258                                                 self, key)
 259                         end
 260                 else
 261                         result = new JsonKeyError("Invalid `[]` access on a `{json_type}` JsonValue.",
 262                                         self, key)
 263                 end
 264                 return new JsonValue(result)
 265         end
 266
 267         # Advanced query to get a value within the map `self` or it's children.
 268         #
 269         # A query is composed of the keys to each map seperated by '.'.
 270         #
 271         # require: `self.is_map`
 272         #
 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(".")
 281                 var value = value
 282                 if is_error then return self
 283                 for i in [0..keys.length[ do
 284                         var key = keys[i]
 285                         if value isa MapRead[String, nullable Object] then
 286                                 if value.has_key(key) then
 287                                         value = value[key]
 288                                 else
 289                                         var sub_query = sub_query_to_s(keys, i)
 290                                         var e = new JsonKeyError("Key `{key}` not found.",
 291                                                         self, sub_query)
 292                                         return new JsonValue(e)
 293                                 end
 294                         else
 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}`",
 298                                                 self, sub_query)
 299                                 return new JsonValue(e)
 300                         end
 301                 end
 302                 return new JsonValue(value)
 303         end
 304
 305         # Concatenate all keys up to `last` for debugging purposes.
 306         #
 307         # Note: This method deletes elements in `keys`.
 308         private fun sub_query_to_s(keys: Array[String], last: Int): String do
 309                 last += 1
 310                 for j in [last..keys.length[ do keys.pop
 311                 return keys.join(".")
 312         end
 313
 314         # Return a human-readable description of the type.
 315         #
 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"
 327                 return "undefined"
 328         end
 329 end
 330
 331 # Keyed access failed.
 332 class JsonKeyError
 333         super Error
 334
 335         # The value on which the access was requested.
 336         var json_value: JsonValue
 337
 338         # The requested key.
 339         #
 340         # In the case of `JsonValue.get`, the sub-query that failed.
 341         var key: Object
 342 end
 343
 344 redef class Text
 345         # Parse `self` to obtain a `JsonValue`
 346         fun to_json_value: JsonValue do
 347                 var value = parse_json
 348                 return new JsonValue(value)
 349         end
 350 end