Scala GraphViz DOT Parser

DotParser.scala:

package scaladot;
 
import scala.util.parsing.combinator._
import scala.util.parsing.combinator.syntactical._
import scala.util.parsing.combinator.lexical._
 
/**
 * A parser for the GraphViz "dot" language. This code is in the public domain.
 
 *  @author Ross Judson
 */
class DotParser extends StdTokenParsers with ImplicitConversions {
  // Fill in abstract defs
  type Tokens = DotLexer
  val lexical = new Tokens
 
  // Configure lexical parsing
  lexical.reserved ++= List("strict", "graph", "digraph", "node", "edge", "subgraph")
  lexical.delimiters ++= List("{", "}", "[", "]", ":", "=", ";", ",", "->", "--","\"")
 
  import lexical._
  
  /** We want to map an Option of None to the empty string identifier,
  and Some(s) to s. 
  */
  implicit def emptyIdentifier(n: Option[String]) = n match {
    case Some(id) => id
    case _ => ""
  }
 
  /** It seems that when we need to get the implicit versions of sequences
  of results out into a list of those results, the automatic conversion
  can be performed by this implicit function. Note that this function 
  uses existential typing; we don't care about the type of the second part
  of the ~'s type, so we ignore it. */
  implicit def convertList[B](lst: List[~[B,_]]) = lst.map(_._1)
  
  //graph  	:  	[ strict ] (graph | digraph) [ ID ] '{' stmt_list '}'
  lazy val dot = opt("strict") ~ ("graph" ^^ false | "digraph" ^^ true) ~ opt(ID) ~ "{" ~ stmt_list ~ "}" ^^
    { case str ~ typ ~ id ~ statements => Graph(str, typ, id, statements:_*) }
    
  //stmt_list  	:  	[ stmt [ ';' ] [ stmt_list ] ]
  lazy val stmt_list = rep(stmt ~ opt(";")) 
  
  // stmt  	:  	node_stmt
  //	| 	edge_stmt
  //	| 	attr_stmt
  //	| 	ID '=' ID
  //	| 	subgraph
  lazy val stmt: Parser[Statement] = subgraph | attr_set | edge_stmt | attr_stmt | node_stmt
  lazy val attr_set = ID ~ "=" ~ a_value ^^ 
    { case left ~ Pair(q,v) => Attr(left, Some(v), q) }
  
  //attr_stmt          :          (graph | node | edge) attr_list
  lazy val  attr_stmt = attr_list_type ~ attr_list ^^
    { case at ~ al => AttrList(at, al:_*) }
  
  lazy val attr_list_type = 
    "graph" ^^ "graph" |
    "node" ^^ "node" |
    "edge" ^^ "edge"
    
  //attr_list  	:  	'[' [ a_list ] ']' [ attr_list ]
  lazy val  attr_list = (("[" ~ a_list ~ "]")*) ^^ 
    { case lists => lists.flatMap(l => l) }
  
  //a_list  	:  	ID [ '=' ID ] [ ',' ] [ a_list ]
  lazy val  a_list = a_part * ","
  lazy val  a_part = log( 
    (ID ~ opt("=" ~ a_value) ^^ { 
      case n ~ Some((q,v)) => Attr(n,Some(v),q)
      case n ~ None => Attr(n, None, false)
      } ))("a_part")
  
  lazy val a_value = 
    accept("string", { case StringLit(v) => (true,v)}) |
    (ID ^^ { case v => (false,v) })
    
  lazy val a_string = log(accept("string", { case StringLit(v) => v }))("a_string")      
  
  //edge_stmt  	:  	(node_id | subgraph) edgeRHS [ attr_list ]
  lazy val  edge_stmt = (node_id | subgraph) ~ "->" ~ rep1sep(node_id | subgraph, "->") ~ attr_list ^^
    { case head ~ rest ~ attrs => Edge("?", attrs, (head :: rest):_*) }
  
  //node_stmt  	:  	node_id [ attr_list ]
  lazy val  node_stmt = node_id ~ attr_list ^^ 
    { case Node(n,p) ~ a => Node(n,p,a:_*) } 
  
  //node_id  	:  	ID [ port ]
  lazy val  node_id = ID ~ opt(port) ^^
    { case n ~ p => Node(n, p) }
   
  //port  	:  	':' ID [ ':' compass_pt ]
  //	| 	':' compass_pt
  lazy val  port = ":" ~ 
    ((ID ~ opt(":" ~ ID)) ^^ flatten2(Port) | 
     ID ^^ { Port (_, None) } ) 
  
  //subgraph  	:  	[ subgraph [ ID ] ] '{' stmt_list '}'
  lazy val  subgraph = "subgraph" ~ opt(ID) ~ "{" ~ stmt_list ~ "}" ^^ 
    { case n ~ s => Subgraph(n, s:_*) }
    
  //compass_pt  	:  	(n | ne | e | se | s | sw | w | nw)
  lazy val compass_pt = 
    "n" ^^ "n"   | 
    "ne" ^^ "ne" | 
    "e" ^^ "e"   | 
    "se" ^^ "se" | 
    "s" ^^ "s"   | 
    "sw" ^^ "sw" | 
    "w" ^^ "w"   | 
    "nw" ^^ "nw"
  
  lazy val ID = IDs | IDi
  lazy val IDs = accept("string", { case StringLit(n) => n })
  lazy val IDi = accept("identifier", { case Identifier(n) => n})
  
}

DotLexer.scala:

package scaladot;
 
import scala.util.parsing.combinator._
import scala.util.parsing.combinator.syntactical._
import scala.util.parsing.combinator.lexical._
import scala.util.parsing.input.CharArrayReader.EofCh
 
class DotLexer extends StdLexical with ImplicitConversions {
 
    override def token: Parser[Token] =
      ( string ^^ StringLit
      | number ~ letter ^^ { case n ~ l => ErrorToken("Invalid number format : " + n + l) }
      | '-' ~ whitespace ~ number ~ letter ^^ { case ws ~ num ~ l => ErrorToken("Invalid number format : -" + num + l) }
      | '-' ~ whitespace ~ number ^^ { case ws ~ num => NumericLit("-" + num) }
      | number ^^ NumericLit
      | EofCh ^^ EOF
      | delim
      | '\"' ~ failure("Unterminated string")
      | id ^^ checkKeyword
      | failure("Illegal character")
      )
 
    // def idcont = letter | digit | underscore
    def id = rep(letter | digit | elem("underscore", _=='_')) ^^ { _ mkString "" } 
      
    // def underscore: Parser[String] = elem('_')
      
    def checkKeyword(strRep: String) = {
      if (reserved contains strRep) Keyword(strRep) else Identifier(strRep)
    }
 
    /** A string is a collection of zero or more Unicode characters, wrapped in
     *  double quotes, using backslash escapes (cf. http://www.json.org/).
     */
    def string = '\"' ~ rep(charSeq | chrExcept('\"', '\n', EofCh)) ~ '\"' ^^ { _ mkString "" }
 
    override def whitespace = rep(whitespaceChar)
 
    def number = intPart ~ opt(fracPart) ~ opt(expPart) ^^ { case i ~ f ~ e =>
      i + optString(".", f) + optString("", e)
    }
    def intPart = zero | intList
    def intList = nonzero ~ rep(digit) ^^ {case x ~ y => (x :: y) mkString ""}
    def fracPart = '.' ~ rep(digit) ^^ { _ mkString "" }
    def expPart = exponent ~ opt(sign) ~ rep1(digit) ^^ { case e ~ s ~ d =>
      e + optString("", s) + d.mkString("")
    }
 
    private def optString[A](pre: String, a: Option[A]) = a match {
      case Some(x) => pre + x.toString
      case None => ""
    }
 
    def zero: Parser[String] = '0' ^^ "0"
    def nonzero = elem("nonzero digit", d => d.isDigit && d != '0')
    def exponent = elem("exponent character", d => d == 'e' || d == 'E')
    def sign = elem("sign character", d => d == '-' || d == '+')
 
    def charSeq: Parser[String] =
      ('\\' ~ '\"' ^^ "\""
      |'\\' ~ '\\' ^^ "\\"
      |'\\' ~ '/'  ^^ "/"
      |'\\' ~ 'b'  ^^ "\b"
      |'\\' ~ 'f'  ^^ "\f"
      |'\\' ~ 'n'  ^^ "\n"
      |'\\' ~ 'r'  ^^ "\r"
      |'\\' ~ 't'  ^^ "\t"
      |'\\' ~ 'u' ~ unicodeBlock)
 
    val hexDigits = Set[Char]() ++ "0123456789abcdefABCDEF".toArray
    def hexDigit = elem("hex digit", hexDigits.contains(_))
 
    private def unicodeBlock = hexDigit ~ hexDigit ~ hexDigit ~ hexDigit ^^ {
      case a ~ b ~ c ~ d =>
        new String(io.UTF8Codec.encode(Integer.parseInt(List(a, b, c, d) mkString "", 16)))
    }
 
    //private def lift[T](f: String => T)(xs: List[Any]): T = f(xs mkString "")
  }
 

And finally, an example of usage, together with the AST for DOT:

package scaladot;
 
object Dot extends DotParser {
 
  def parse(input: String) =
    phrase(dot)(new lexical.Scanner(input)) match {
      case Success(result, _) => println("Success!"); Some(result)
      case n @ _ => println(n); None
    }  
  
  
  def main(args: Array[String]) {
    val x = parse("""
      digraph acm {
        hello -> world;
        test:up:n -> world;
        style = filled;
        
        subgraph cluster {
          node [style=filled,color=white];
          toast -> bingo;
          zot -> bingo;
          zot -> test;
          style=filled;
          color=lightgrey;
          label = "Below";
        }        
 
    }
    
    """)
 
    println(x)
      
  }
}
 
abstract class DotComponent {
  override def toString = {
    val b = new StringBuilder
    buildString(0, b)
    b.toString()
  }
  
  private def indent(level: Int, b: StringBuilder) {
    for (i <- 0 to level) b append ' ' 
  }
  
  def buildString(implicit level: Int, b: StringBuilder) {
    
    def between(sep: String, things: Seq[DotComponent])(implicit lev: Int) {
      var first = true
      for (t <- things) {
        if (first) first = false else b append sep
        t.buildString(lev, b)
      }
    }
    
    def betweenList(before: String, sep: String, after: String, things: Seq[DotComponent])(implicit lev: Int) {
      if (!things.isEmpty) {
        b append before
        between(sep, things)(lev)
        b append after
      }
    }
 
    this match {
    case Port(id, compass) =>
      b append id
      if (compass != None) b append ':' append compass.get
    case Graph(strict, digraph, id, statements @ _*) =>
      indent(level,b)
      if (strict) b append "strict "
      b append (if (digraph) "digraph " else "graph ")
      betweenList(id + " {\n", "\n", "}\n", statements)(level+1)
    case AttrList(kind, attrs @ _*) =>
      indent(level,b)
      b append kind
      betweenList(" [", ",", "]", attrs)(0)
    case Attr(n, Some(v), q) => 
      indent(level,b)
      b append n append '='
      if (q) b append '"'
      b append v
      if (q) b append '"'
    case Attr(n,_,_) => b append n
    case Edge(_, attrs, nodes @ _*) =>
      indent(level,b)
      between(" -> ", nodes)
      betweenList(" [", ",", "]", attrs)(0)
    case Subgraph(id, statements @ _*) =>
      indent(level,b)
      b append "subgraph " append id 
      betweenList(" {\n", "\n", "\n", statements)(level+1)
      indent(level,b)
      b append "}\n"
    case Node(id, port, attrs @ _*) =>
      b append id
      if (port != None) { b append ':'; port.get.buildString(level, b) }
      betweenList(" [", ", ", " ]\n", attrs)
  } }
  
}
 
/** Implemented by DOT components that are allowed to have an identity
*/
trait Identified extends DotComponent {
  val id: String
}
 
/** Implemented by DOT components that are statements, for use within
graphs and subgraphs. */
trait Statement extends DotComponent 
 
/** Implemented by DOT components that have a list of attributes associated
with them. */
trait Attributed extends DotComponent {
  val attrs: Seq[Attr]
}
 
/** Implemented by DOT components that can participate in an edge; currently
Node and Subgraph. */
trait EdgeComponent extends Identified
 
/** The abstract base for the two graph components of DOT -- graph (digraph)
and subgraph. */
abstract class AbstractGraph extends DotComponent with Identified {
  val statements: Seq[Statement]
}
/** Nodes can have an optional port identifier. The port identifier can have
an optional compass direction. */
case class Port(id: String, compass: Option[String]) extends DotComponent 
 
case class Graph(strict: Boolean, digraph: Boolean, id: String, statements: Statement*) extends AbstractGraph
 
//
// Statements
//
case class AttrList(kind: String, attrs: Attr*) extends Statement with Attributed
case class Attr(name: String, value: Option[String], quoted: Boolean) extends Statement
case class Edge(id: String, attrs: Seq[Attr], nodes: EdgeComponent*) extends Identified with Statement with Attributed
case class Subgraph(id: String, statements: Statement*) extends AbstractGraph with EdgeComponent with Statement
case class Node(id: String, port: Option[Port], attrs: Attr*) extends EdgeComponent with Statement with Attributed