Json Parser

package org.logikujo.atuin.Json

import org.parboiled.scala._
import org.parboiled.support._
import org.parboiled.scala.parserunners.ReportingParseRunner

class JsonParser extends Parser {
  def Json: Rule0  = rule {
    WhiteSpace ~ ArrayJson |
    WhiteSpace ~ ObjectJson }

  def ArrayJson: Rule0 = rule {
    WhiteSpace ~ "[" ~ WhiteSpace ~
    zeroOrMore(ValueJson, separator = WhiteSpace ~ "," ~ WhiteSpace) ~
    WhiteSpace ~ "]"}

  def ObjectJson = rule {
    WhiteSpace ~ "{" ~ WhiteSpace ~
    zeroOrMore(Pair, separator = WhiteSpace ~ "," ~ WhiteSpace) ~
    WhiteSpace ~ "}"}

  def Pair = rule {
    StringJson ~ WhiteSpace ~
    ":" ~
    WhiteSpace ~ ValueJson
  }

  def StringJson = rule { "\"" ~ zeroOrMore(Char) ~ "\""}

  def Char = { EscapedChar | NormalChar}

  def EscapedChar = { "\\" ~ anyOf("\"\\/bfnrt") | Unicode }

  def Unicode = { "\\u" ~ nTimes(4, HexDigit)}

  def HexDigit = {"0" - "9" | "a" - "f" | "A" - "F"}

  def NormalChar = {!anyOf("\"\\") ~ ANY}

  def ValueJson:Rule0 = {StringJson | IntegerJson | ObjectJson | ArrayJson |
    ignoreCase("true") | ignoreCase("false") | ignoreCase("null")}

  def IntegerJson = rule {
    optional(anyOf("+-")) ~
    DigitsJson ~
    optional((FractionJson ~ optional(ExponentJson)) |
      ExponentJson)}

  def DigitsJson = rule {oneOrMore("0" - "9")}

  def FractionJson = rule {"." ~ DigitsJson}

  def ExponentJson = rule {ignoreCase('e') ~ optional(anyOf("+-")) ~ DigitsJson}

  def Separator = rule {zeroOrMore(WhiteSpace) ~ "," ~ zeroOrMore(WhiteSpace)}

  def WhiteSpace = rule {zeroOrMore(anyOf(" \n\r\t\f")) }
}

case class Json (input:String) extends JsonParser {
  private lazy val parser = new JsonParser {override val buildParseTree = true}
  lazy val result = ReportingParseRunner(parser.Json).run(input)

  override def toString = ParseTreeUtils.printNodeTree(result)
}