ported to scala 2.10.1, unfiltered 0.6.8

build.properties

@@ -0,0 +1 @@
+sbt.version=0.12.+

project/Build.scala

@@ -0,0 +1,33 @@
+import sbt._
+import Keys._
+
+object ReplHtmlBuild extends Build {
+  val mySettings = Defaults.defaultSettings ++ Seq(
+    organization := "ch.epfl.lamp",
+    name         := "replhtml",
+    version      := "1.1",
+    scalaVersion := "2.10.1",
+    libraryDependencies := Seq(
+      "org.scala-lang" % "scala-compiler" % "2.10.1",
+      "org.scala-lang" % "scala-reflect" % "2.10.1",
+      "org.scala-lang" % "scala-library" % "2.10.1",
+      "net.databinder" %% "unfiltered-filter" % "0.6.8",
+      "net.databinder" %% "unfiltered-netty-server" % "0.6.8",
+      "net.databinder" %% "unfiltered-netty-websockets" % "0.6.8")
+  )
+
+  val setupReplClassPath = TaskKey[Unit]("setup-repl-classpath", "Set up the repl server's classpath based on our dependencies.")
+
+  lazy val project = Project (
+    "replhtml",
+    file ("."),
+    settings = mySettings ++ Seq(
+      setupReplClassPath <<= (dependencyClasspath in Compile) map {cp =>
+        val cpStr = cp map { case Attributed(str) => str} mkString(System.getProperty("path.separator"))
+        println("Repl will use classpath "+ cpStr)
+        System.setProperty("replhtml.class.path", cpStr)
+      },
+      run in Compile <<= (run in Compile).dependsOn(setupReplClassPath)
+    )
+  )
+}

src/main/scala/ReplMain.scala

@@ -1,30 +1,64 @@
 package ch.epfl.lamp.replhtml
 
-//import javax.servlet.http._
-import org.eclipse.jetty.server.Server
-import org.eclipse.jetty.servlet.ServletContextHandler
-import org.eclipse.jetty.servlet.ServletHolder
-import org.eclipse.jetty.servlet.DefaultServlet
+import unfiltered.netty.websockets._
 
 object ReplMain {
   def main(args: Array[String]) {
-    val server = new Server(8080)
+    val sockets = collection.mutable.ListBuffer.empty[WebSocket]
+    // TODO: WebSocketServer is deprecated in unfiltered 0.6.8
+    WebSocketServer("/socket/repl", 8080) {
+      case Open(s) => sockets += s
+      case Message(s, Text(str)) =>
+        println(s"message: $str"); val resp = handle(str); println(s"Response: $resp"); sockets foreach (_.send(resp))
+      case Close(s) => sockets -= s
+      case Error(s, e) => println(s"error ${e.getMessage}")
+    } run ()
+  }
+
+  import scala.tools.nsc._
+  import scala.tools.nsc.interpreter._
+
+  val cmd = new CommandLine(Nil, println)
+  import cmd.settings
+  settings.classpath.value = System.getProperty("replhtml.class.path")
+
+  val interpreter = new IMain(settings)
+  val completion = new JLineCompletion(interpreter)
+  // interpreter.bind("servlet", "ch.epfl.lamp.replhtml.ReplServlet", ReplServlet.this) }
+  // interpreter.unleash()
+
+  def handle(data: String): String = {
+    val idx = data.indexOf(":")
+    val key = if (idx > 0) data.substring(0, idx) else ""
+    var source = if (idx >= 0) data.substring(idx + 1) else data
 
-    val context = new ServletContextHandler(ServletContextHandler.SESSIONS)
-    context.setContextPath("/")
-    server.setHandler(context)
+    key match {
+      case "complete" =>
+        val idx = source.indexOf(":")
+        val ipos = Integer.parseInt(source.substring(0, idx))
+        source = source.substring(idx + 1)
 
-    context.addServlet(new ServletHolder(new ReplServlet()),"/socket/*")
-    context.addServlet(new ServletHolder(new DefaultServlet()),"/*")
+        val res = if (ipos <= source.length) {
+          val tokens = source.substring(0, ipos).split("""[\ \,\;\(\)\{\}]""") // could tokenize on client
+          println("try to complete: " + tokens.mkString(","))
+          if (tokens.nonEmpty) {
+            val cmpl = completion.topLevelFor(Parsed.dotted(tokens.last, ipos) withVerbosity 4) // (?)
+            "<completion>:" + ipos + "\n" + cmpl.mkString("\n")
+          } else "<completion>:" + ipos + "\n"
+        } else "<completion>:" + ipos + "\n"
+        println("res: " + res)
+        res
 
-    server.start()
-    println(">>> embedded jetty server started. press any key to stop.")
-    while (System.in.available() == 0) {
-      Thread.sleep(1500)
+      case _ =>
+        util.stringFromStream { ostream =>
+          Console.withOut(ostream) {
+            interpreter.interpret(source) match {
+              case IR.Error => println("<done:error>")
+              case IR.Success => println("<done:success>")
+              case IR.Incomplete => println("<done:incomplete>")
+            }
+          }
+        }
     }
-    System.in.read()
-    println(">>> stopping...")
-    server.stop()
-    server.join()
   }
-}
+}