// Parses a JSON file into a tree and prints it back, two spaces per level.
//
// nikaia run -- tests/document.in/data.json
// {
// "name": "a\nb",
// …
// }
// longest string: 3 characters
//
// Any JSON file will do; a one-line one is enough:
// `{"name": "a\nb", "tags": [1, 2.5, true, null], "empty": {}}`.
//
// Shows: an `enum` as a recursive tree, a recursive `grammar`, strings kept as
// views of the input and decoded only when asked, and a `match` the compiler
// checks for missing cases.
//
// A package: `nikaia run` in this directory runs it, and `nikaia test` checks
// what it prints against `tests/` (ADR-269 D13).
use std::fs
use std::cli
// A JSON value is one of six things, which is what an enum says. `Array` and
// `Object` hold more `Json`, so the type is a tree of any depth.
//
// `Text` holds a view into the input, so `Json` and `Member` are tied to the
// text they were parsed from. Neither declaration has to say so: the compiler
// works it out, through the cycle.
enum Json {
Null,
Bool(bool),
Number(f64),
Text(String),
Array(Vec[Json]),
Object(Vec[Member]),
}
pub struct Member {
key: String,
value: Json,
}
grammar Json_ {
// A lowercase rule skips whitespace between its parts, so nothing below
// mentions blanks, and `[1, 2]` and a document spread over forty lines
// parse the same. `value` reaches `value` again through `[` and `{`.
entry rule value -> Json =
"null" -> { Json::Null }
| "true" -> { Json::Bool(true) }
| "false" -> { Json::Bool(false) }
| n:NUMBER -> { Json::Number(n) }
| s:TEXT -> { Json::Text(s) }
| "[" "]" -> { Json::Array(Vec()) }
| "[" items:values "]" -> { Json::Array(items) }
| "{" "}" -> { Json::Object(Vec()) }
| "{" members:members "}" -> { Json::Object(members) }
// A comma-separated list: a head and a repetition, collected in the
// action. `values = values "," value` would never terminate.
rule values -> Vec[Json] =
head:value tail:value_tail* -> {
let mut all = Vec()
all.push(head)
for v in tail.drain() { all.push(v) }
all
}
rule value_tail -> Json = "," v:value -> { v }
rule members -> Vec[Member] =
head:member tail:member_tail* -> {
let mut all = Vec()
all.push(head)
for m in tail.drain() { all.push(m) }
all
}
rule member_tail -> Member = "," m:member -> { m }
rule member -> Member = k:TEXT ":" v:value -> { Member { key: k, value: v } }
// An uppercase rule skips nothing, so the sign, the digits and the fraction
// are one run with nothing between them. `dec[f64](…)` converts the text
// the pattern matched.
rule NUMBER -> f64 =
n:dec[f64](text("-"? digit+ ("." digit+)? )) -> { n }
// The body between the quotes, raw: escapes are kept as written. The body
// `a\nb` is four characters in the file and three once decoded, so a JSON
// string cannot simply be a slice of the input; the raw body can.
//
// An escape is a backslash and whatever follows it; anything else is a
// character that is neither a quote nor a backslash. `text(…)` hands back
// the input the repetition covered, as a view: one slice, no copy.
rule TEXT -> String = "\"" s:text((ESC | PLAIN)*) "\"" -> { s }
rule ESC = "\\" any -> { }
rule PLAIN = not("\"") not("\\") any -> { }
}
// The document, printed back with two spaces per level.
//
// Six arms and no `else`: a variant added to `Json` makes this `match` a
// compile error until it is handled.
//
// Strings are printed back raw, as they were in the file, so printing never
// decodes and never has to re-escape.
fn show(value: Json, indent: i64) {
let pad = " ".repeat(indent)
let inner = " ".repeat(indent + 1)
match value {
Json::Null => { print("null") }
Json::Bool(b) => { if b { print("true") } else { print("false") } }
Json::Number(n) => { print(f"{n}") }
Json::Text(raw) => { print(f"\"{raw}\"") }
Json::Array(items) => {
if items.len() == 0 {
print("[]")
} else {
print("[\n")
let mut first = true
for item in items.drain() {
if !first { print(",\n") }
first = false
print(f"{inner}")
show(item, indent + 1)
}
print(f"\n{pad}]")
}
}
// A brace in a plain string is just a brace: `print("{}")` prints `{}`.
// Only an f-string reads `{…}`, and there `}}` stands for one `}`.
Json::Object(fields) => {
if fields.len() == 0 {
print("{}")
} else {
print("{\n")
let mut first = true
for field in fields.drain() {
if !first { print(",\n") }
first = false
print(f"{inner}\"{field.key}\": ")
show(field.value, indent + 1)
}
print(f"\n{pad}}}")
}
}
}
}
// What a JSON escape means. This is the only place a string is decoded.
//
// `\u` is not handled: `\u0041` comes out as `u0041`, not `A`.
fn unescape(raw: String) -> String {
let mut out = String()
let mut escaped = false
for c in raw.chars() {
if escaped {
match c {
'n' => { out.push('\n') }
't' => { out.push('\t') }
'r' => { out.push('\r') }
'b' => { out.push_str("\u{0008}") }
'f' => { out.push_str("\u{000C}") }
// `\"`, `\\` and `\/` stand for themselves.
else => { out.push(c) }
}
escaped = false
} else {
if c == '\\' { escaped = true } else { out.push(c) }
}
}
return out
}
// The longest decoded string in the document, in characters. It takes the
// tree by `ref` because `main` still prints it afterwards; `show` takes it by
// value, being the last to look.
fn longest(value: ref Json) -> i64 {
match value {
Json::Text(raw) => return unescape(raw).chars().count() as i64
Json::Array(items) => {
let mut best = 0
for item in items {
let n = longest(item)
if n > best { best = n }
}
return best
}
Json::Object(fields) => {
let mut best = 0
for field in fields {
let n = longest(field.value)
if n > best { best = n }
}
return best
}
else => return 0
}
}
fn main() throws {
let path = cli::args().nth(1) ?? "data.json"
let text = fs::read_to_string(ref path, fs::Root::Anywhere) catch {
eprintln(f"cannot read {path}: {error}")
return
}
let document = Json_::value(text) catch {
eprintln(f"{path}: {error}")
return
}
let widest = longest(document)
show(document, 0)
println("")
println(f"longest string: {widest} characters")
}The file itself · all the examples