steinbit.org

import scala.util.matching.Regex
import scala.util.parsing.combinator._
 
/**
 * Query Syntax
 *   query         ::= {query-path `.`} query-leaf query-value?
 *   query-path    ::= name-path filters?
 *   query-leaf    ::= name-leaf
 *   query-value   ::= `=` <a xml element>
 *   name-path     ::= ([a-zA-Z][-a-zA-Z0-9]*)
 *   name-leaf     ::= ([a-zA-Z][-a-zA-Z0-9]*)|[?]
 *   filters       ::= `[` {filter `,`} `]`
 *   filter        ::= filter-key `=` `'` filter-value `'`
 *   filter-key    ::= [a-zA-Z][-a-zA-Z0-9]*
 *   filter-value  ::= `'` <an escaped string> `'`
 */
trait Queryable {
  import Queryable._
 
  private val queryKeys: () => Seq[xml.Elem] =
    () => {
      for (item <- queryMap.keys.toSeq) yield {
        <key name={item} doc={queryMap(item)._1} type={queryMap(item)._2.typeId}/>
      }
    }
 
  protected var queryMap = Map[String,(String,QueryNode)](
    "?" -> (
      "Lists all queryable keys." -> QueryVal(
        read = queryKeys
      )
    )
  )
 
  final def query(expr: String): Either[String,xml.Elem] = {
    try {
      val parser = new QueryParser
      parser.parseAll(parser.queryPath, expr) match {
        case parser.Success((path,value), remaining) =>
          Right(<query expr={expr}>{ query(path,value) }</query>)
        case parser.Error(msg, remaining) =>
          Left("error while parsing query: " + msg)
        case parser.Failure(msg, remaining) =>
          Left("failure while parsing query: " + msg)
        case err =>
          Left("unknown error while parsing query: " + err)
      }
    }
    catch {
      case exp: Exception => Left("exception caught during query: " + exp)
    }
  }
 
  private def query(path: Seq[Prop], value: Option[xml.Elem]): Seq[xml.Elem] = {
    path.toList match {
      case (key,filters) :: Nil if queryMap contains key =>
        (queryMap(key)._2,value) match {
          case (QueryVal(read),None)           => read()
          case (QueryVar(read,_),None)         => read()
          case (QueryVar(_,write),Some(value)) => write(value)
          case (QueryDef(apply),Some(value))   => apply(value)
          case _                               => Nil
        }
      case (key,filters) :: tail if queryMap contains key =>
        queryMap(key)._2 match {
          case QueryPath(next) =>
            next()
              .filter(node => filters.forall(item => contains(node,item)))
              .flatMap(node => node.query(tail,value))
          case _ => Nil
        }
      case _ => Nil
    }
  }
 
  private def contains(node: Queryable, check: (String,String)): Boolean = {
    if (node.queryMap.contains(check._1) == false) {
      false
    }
    else {
      val regex = new Regex(check._2)
      node.queryMap(check._1)._2 match {
        case QueryVal(read) =>
          read().headOption.exists(
            item => regex.findPrefixOf(item.text).isDefined
          )
        case QueryVar(read,_) =>
          read().headOption.exists(
            item => regex.findPrefixOf(item.text).isDefined
          )
        case _ => false
      }
    }
  }
}
 
 
object Queryable {
  import xml.XML.{loadString => toXml}
 
  private type Prop = (String,Map[String,String])
 
  sealed trait QueryNode {
    def typeId(): String
  }
  case class QueryVal(read: () => Seq[xml.Elem]) extends QueryNode {
    def typeId(): String = "val"
  }
  case class QueryVar(read: () => Seq[xml.Elem],
                      write: xml.Elem => Seq[xml.Elem]) extends QueryNode {
    def typeId(): String = "var"
  }
  case class QueryDef(apply: xml.Elem => Seq[xml.Elem]) extends QueryNode {
    def typeId(): String = "def"
  }
  case class QueryPath(next: () => Seq[Queryable]) extends QueryNode {
    def typeId(): String = "path"
  }
 
  private class QueryParser extends JavaTokenParsers {
    def queryPath: Parser[(Seq[Prop],Option[xml.Elem])] =
      repsep(query, ".") ~ opt(white ~ "=" ~> white ~> queryValue) ^^ {
        case path ~ value => (path,value)
      }
 
    def query: Parser[Prop] =
      queryName ~ opt(queryFilters) ^^ {
        case name ~ Some(filters) => (name,filters)
        case name ~ None          => (name,Map())
      }
 
    def queryName: Parser[String] = """([a-zA-Z][-a-zA-Z]*)|[\?]""".r
 
    def queryFilters: Parser[Map[String,String]] =
      "[" ~ white ~> repsep(queryFilter, white ~> "," <~ white) <~ "]" ^^ {
        (Map() ++ _)
      }
 
    def queryFilter: Parser[(String,String)] =
      filterKey ~ "=" ~ filterValue ^^ {
        case key ~ "=" ~ value => (key,value)
      }
 
    def queryValue(): Parser[xml.Elem] =
      new Parser[xml.Elem] {
        def apply(in: Input): ParseResult[xml.Elem] = {
          // manually parse xml element from text
          val (begin,end) = (in.offset,in.source.length)
          if (begin >= end) {
            Error("Empty value", in)
          }
          else {
            val elem = toXml(in.source.subSequence(begin,end).toString)
            Success(elem, in.drop(end - begin))
          }
        }
      }
 
    def filterKey: Parser[String] = """[a-zA-Z][-a-zA-Z]*""".r
 
    def filterValue: Parser[String] =
      "'" ~> """[^']+""".r <~ "'" ^^ {
        (value: String) => value
      }
 
    def white: Parser[Option[String]] = opt("""[ \t]+""".r)
  }
}

case class Song(title: String, composer: String, duration: String)
  extends Queryable {
  import Queryable._
 
  queryMap += (
    "title" -> ("The song's title." -> QueryVal(
      read = () => {<title>{title}</title> :: Nil}
    )),
    "composer" -> ("The song's composer." -> QueryVal(
      read = () => {<composer>{composer}</composer> :: Nil}
    )),
    "xml" -> ("Transform into xml." -> QueryVal(
      read = () => {<song title={title} composer={composer} duration={duration}/> :: Nil}
    ))
  )
}
 
class Jukebox extends Queryable {
  import Queryable._
 
  private var status = "idle"
  private var songs  = List.empty[Song]
 
  def queue(song: Song) { songs = song :: songs }
 
  queryMap += (
    "xml" -> ("Transform into xml." -> QueryVal(
      read = () => {<jukebox status={status} size={songs.length.toString}/> :: Nil}
    )),
    "status" -> ("Status of jukebox." -> QueryVal(
      read = () => {<status>{status}</status> :: Nil}
    )),
    "songs" -> ("Traverse to songs." -> QueryPath(
      next = () => {songs}
    )),
    "queue" -> ("Queues a song from xml." -> QueryDef(
       apply = (elem: xml.Elem) => {
         val song = Song(
           title    = (elem \ "@title").text,
           composer = (elem \ "@composer").text,
           duration = (elem \ "@duration").text
         )
         songs = song :: songs
         <queue>done</queue> :: Nil
       }
    ))
  )
}
 
class App extends Queryable {
  import Queryable._
 
  var status = "ready"
  val jukebox = new Jukebox
 
  queryMap += (
    "xml" -> ("Transform into xml." -> QueryVal(
      read = () => {<app status={status}/> :: Nil}
    )),
    "jukebox" -> ("Traverse to jukebox." -> QueryPath(
      next = () => {jukebox :: Nil}
    ))
  )
}

def print(value: Either[String,xml.Elem]) {
  val printer = new xml.PrettyPrinter(width=80,step=2)
  value match {
    case Right(result) => println(printer format result)
    case Left(error)   => println(error)
  }
}

val app = new App
print(app query "?")
print(app query "jukebox.?")

<query expr="?">
  <key doc="Lists all queryable keys." type="val" name="?"></key>
  <key doc="Transform into xml." type="val" name="xml"></key>
  <key doc="Traverse to jukebox." type="path" name="jukebox"></key>
</query>
<query expr="jukebox.?">
  <key doc="Queues a song from xml." type="def" name="queue"></key>
  <key doc="Traverse to songs." type="path" name="songs"></key>
  <key doc="Transform into xml." type="val" name="xml"></key>
  <key doc="Status of jukebox." type="val" name="status"></key>
  <key doc="Lists all queryable keys." type="val" name="?"></key>
</query>

app.jukebox.queue(Song(title="Mars", composer="Gustav Holst", duration="7m05s"))
app.jukebox.queue(Song(title="Jupiter", composer="Gustav Holst", duration="7m51s"))
print(app query "jukebox.status")
print(app query "jukebox.songs.xml")

<query expr="jukebox.status">
  <status>idle</status>
</query>
<query expr="jukebox.songs.xml">
  <song composer="Gustav Holst" title="Jupiter" duration="7m51s"></song>
  <song composer="Gustav Holst" title="Mars" duration="7m05s"></song>
</query>

print(app query "jukebox.songs[title='Ma',composer='Gustav'].xml")

<query expr="jukebox.songs[title='Ma',composer='Gustav'].xml">
  <song composer="Gustav Holst" title="Mars" duration="7m05s"></song>
</query>

print(app query ("jukebox.queue = " + <song title="Nocturnes III" composer="Claude Debussy" duration="10m40s"/>))

<query
expr="jukebox.queue = &lt;song composer=&quot;Claude Debussy&quot; title=&quot;Nocturnes III&quot; duration=&quot;10m40s
&quot;&gt;&lt;/song&gt;">
  <queue>done</queue>
</query>

print(app query "jukebox.songs[composer='Claude'].xml")

<query expr="jukebox.songs[composer='Claude'].xml">
  <song composer="Claude Debussy" title="Nocturnes III" duration="10m40s"></song>
</query>

import java.io.{PrintWriter,StringWriter}
import java.util.regex.{Pattern,Matcher}
 
trait Loggable[+T <: Loggable[T]] {
  this: T => // type this trait with the subclass that uses it
 
  import Loggable._
 
  // attributes required by this trait
  protected val logger: Logger
 
  // methods required by this trait
  protected def getLogCompanion(): LogCompanion[T]
 
  // predefined methods
  protected final def error(msg: String, tags: String*): Boolean = {
    val trace = (new Exception).getStackTrace()(2)
    val who   = toDot(trace.getClassName) + "." + toDot(trace.getMethodName)
    val where = trace.getFileName + ":" + trace.getLineNumber
    logger.writer.error(msg,who,where,tags:_*)
  }
 
  protected final def error(exp: Throwable, tags: String*): Boolean = {
    val trace = (new Exception).getStackTrace()(2)
    val who   = toDot(trace.getClassName) + "." + toDot(trace.getMethodName)
    val where = trace.getFileName + ":" + trace.getLineNumber
    logger.writer.error(expToString(exp),who,where,tags:_*)
  }
 
  protected final def fail(msg: String, tags: String*): Nothing = {
    val trace = (new Exception).getStackTrace()(2)
    val who   = toDot(trace.getClassName) + "." + toDot(trace.getMethodName)
    val where = trace.getFileName + ":" + trace.getLineNumber
    logger.writer.fail(msg,who,where,tags:_*)
  }
 
  protected final def debug(msg: String, tags: String*) {
    // the tag "all" controls all debug logging
    if (logger.checker("all") &&
        getLogCompanion.DebugTags.exists(tag => logger.checker(tag))) {
      val trace = (new Exception).getStackTrace()(2)
      val who   = toDot(trace.getClassName) + "." + toDot(trace.getMethodName)
      val where = trace.getFileName + ":" + trace.getLineNumber
      logger.writer.debug(msg,who,where,tags:_*)
    }
  }
 
  protected final def info(msg: String, tags: String*) {
    val trace = (new Exception).getStackTrace()(2)
    val who   = toDot(trace.getClassName) + "." + toDot(trace.getMethodName)
    val where = trace.getFileName + ":" + trace.getLineNumber
    logger.writer.info(msg,who,where,tags:_*)
  }
 
  protected final def warn(msg: String, tags: String*) {
    val trace = (new Exception).getStackTrace()(2)
    val who   = toDot(trace.getClassName) + "." + toDot(trace.getMethodName)
    val where = trace.getFileName + ":" + trace.getLineNumber
    logger.writer.warn(msg,who,where,tags:_*)
  }
}
 
object Loggable {
 
  // traits required by Loggable
  trait LogCompanion[+T <: Loggable[_]] {
    val DebugTags: Set[String]
  }
 
  trait Logger {
    val checker: LogChecker
    val writer: LogWriter
  }
 
  trait LogChecker {
    def update(tag: String, isEnabled: Boolean): Unit
    def apply(tag: String): Boolean
  }
 
  trait LogWriter {
      def debug(msg: String, who: String, where: String,tags: String*): Unit
      def error(msg: String, who: String, where: String, tags: String*): Boolean
      def fail(msg: String, who: String, where: String, tags: String*): Nothing
      def info(msg: String, who: String, where: String, tags: String*): Unit
      def warn(msg: String, who: String, where: String, tags: String*): Unit
  }
 
  // utility function
  private val SlashPattern = Pattern.compile("\\\\")
 
  private def toDot(str: String): String = {
    val matcher = SlashPattern.matcher(str)
    matcher.replaceAll(".")
  }
 
  private def expToString(exp: Throwable): String = {
    val writer = new StringWriter
    exp.printStackTrace(new PrintWriter(writer))
    writer.toString
  }
}

import Loggable._
 
// common trait for tunes that Jukebox can use
trait Playable {
  this: Loggable[_] =>
 
  def play(): Unit = info("Started playing " + this)
  def stop(): Unit = info("Stopped playing " + this)
}
 
// the secondary implicit list of arguments are resolved at compile-time by
// the compiler, which will replace these arguments with any available implicitly
// defined objects that satisfy the type. Multiple objects are resolved by using
// the most specific one. There are also rules for how the compiler does search.
class Jukebox()(implicit protected val logger: Logger)
  extends Loggable[Jukebox] {
 
  import scala.collection.immutable.Queue
 
  protected var tunes = Queue[Playable]()
 
  debug("Created " + this)
 
  override def toString(): String = "(Jukebox tunes: " + tunes.mkString("[",",","]") + ")"
 
  protected def getLogCompanion(): LogCompanion[Jukebox] = Jukebox
 
  def queue(tune: Playable) {
    tunes = tunes.enqueue(tune)
    debug("Queued " + tune + " on " + this)
  }
 
  def kick(): Unit = fail("Crashed " + this)
 
  def play() {
    if (tunes.isEmpty)
      return warn("No more tunes to play on " + this)
 
    val (tune,rest) = tunes.dequeue
    tunes = rest
    tune.play()
    tune.stop()
  }
}
 
object Jukebox extends LogCompanion[Jukebox] {
  val DebugTags = Set("jukebox")
}
 
class Song(val name: String)(implicit protected val logger: Logger)
  extends Playable with Loggable[Song] {
 
  debug("Created " + this)
  override def toString(): String = "(Song name: \"" + name + "\")"
  protected def getLogCompanion(): LogCompanion[Song] = Song
}
 
object Song extends LogCompanion[Song] {
  val DebugTags = Set("song")
}
 
// override the logCompanion of Song
class Jingle(name0: String)(implicit logger: Logger)
  extends Song(name0) {
  debug("Created " + this)
  override def toString(): String = "(Jingle name: \"" + name + "\")"
  override protected def getLogCompanion(): LogCompanion[Song] = Jingle
}
 
object Jingle extends LogCompanion[Jingle] {
  val DebugTags = Set("jingle") ++ Song.DebugTags
}

// instantiating the logging  checker and writer
implicit val logger = new Logger {
  var enabledTags = Set("all","song","jukebox","jingle")
  var disabledTags = Set()
 
  val checker = new LogChecker {
    def update(tag: String, isEnabled: Boolean) {
      enabledTags = if (isEnabled) enabledTags + tag else enabledTags - tag
    }
    def apply(tag: String): Boolean = enabledTags contains tag
  }
 
  val writer = new LogWriter {
    def debug(msg: String, who: String, where: String, tags: String*) {
      println("\n--debug " + who + " " + where + "\n" + msg)
    }
    def error(msg: String, who: String, where: String, tags: String*): Boolean = {
      println("--error " + who + " " + where + "\n" + msg)
      false
    }
    def fail(msg: String, who: String, where: String, tags: String*): Nothing = {
      println("\n--fail " + who + " " + where + "\n" + msg)
      throw new java.lang.AssertionError(
        "msg: " + msg + " who: " + who + " where: " + where
      )
    }
    def info(msg: String, who: String, where: String, tags: String*) {
      println("\n--info " + who + " " + where + "\n" + msg)
    }
    def warn(msg: String, who: String, where: String, tags: String*) {
      println("\n--warn " + who + " " + where + "\n" + msg)
    }
  }
}
 
// creating some test objects
val jukebox = new Jukebox
jukebox.queue(new Song("that ol' tune"))
jukebox.queue(new Song("dum di dum"))
jukebox.queue(new Jingle("snap! snap!"))
jukebox.play()
jukebox.play()
jukebox.play()
jukebox.play()
jukebox.kick()

--debug Main$$anon$4$Jukebox.<init> Debug.scala:123
Created (Jukebox tunes: [])
 
--debug Main$$anon$4$Song.<init> Debug.scala:153
Created (Song name: "that ol' tune")
 
--debug Main$$anon$4$Jukebox.queue Debug.scala:129
Queued (Song name: "that ol' tune") on (Jukebox tunes: [(Song name: "that ol' tune")])
 
--debug Main$$anon$4$Song.<init> Debug.scala:153
Created (Song name: "dum di dum")
 
--debug Main$$anon$4$Jukebox.queue Debug.scala:129
Queued (Song name: "dum di dum") on (Jukebox tunes: [(Song name: "that ol' tune"),(Song name: "dum di dum")])
 
--debug Main$$anon$4$Song.<init> Debug.scala:153
Created (Jingle name: "snap! snap!")
 
--debug Main$$anon$4$Jingle.<init> Debug.scala:166
Created (Jingle name: "snap! snap!")
 
--debug Main$$anon$4$Jukebox.queue Debug.scala:129
Queued (Jingle name: "snap! snap!") on (Jukebox tunes: [(Song name: "that ol' tune"),(Song name: "dum di dum"),(Jingle name: "snap! snap!")])
 
--info Main$$anon$4$Playable$class.play Debug.scala:107
Started playing (Song name: "that ol' tune")
 
--info Main$$anon$4$Playable$class.stop Debug.scala:108
Stopped playing (Song name: "that ol' tune")
 
--info Main$$anon$4$Playable$class.play Debug.scala:107
Started playing (Song name: "dum di dum")
 
--info Main$$anon$4$Playable$class.stop Debug.scala:108
Stopped playing (Song name: "dum di dum")
 
--info Main$$anon$4$Playable$class.play Debug.scala:107
Started playing (Jingle name: "snap! snap!")
 
--info Main$$anon$4$Playable$class.stop Debug.scala:108
Stopped playing (Jingle name: "snap! snap!")
 
--warn Main$$anon$4$Jukebox.play Debug.scala:136
No more tunes to play on (Jukebox tunes: [])
 
--fail Main$$anon$4$Jukebox.kick Debug.scala:133
Crashed (Jukebox tunes: [])
java.lang.AssertionError: msg: Crashed (Jukebox tunes: []) who: Main$$anon$4$Jukebox.kick where: Debug.scala:133
        at Main$$anon$4$$anon$1$$anon$3.fail(Debug.scala:197)
        at Main$$anon$4$Loggable$class.fail(Debug.scala:33)
        at Main$$anon$4$Jukebox.fail(Debug.scala:116)
        at Main$$anon$4$Jukebox.kick(Debug.scala:133)
        at Main$$anon$4.<init>(Debug.scala:219)
        at Main$.main(Debug.scala:1)
        at Main.main(Debug.scala)
        ...