The simplest dynamically typed json parsing with Dynamic in Scala 2.10

I love the way dynamically typed languages handle json or xml parsing. With Scala 2.10 we can do it using Dynamic trait. Here is a first draft.
Please feel free to copy/paste/reuse at your own risk.

	import util.parsing.json.JSON
	import io.Source
	import scala.language.dynamics
	object Example extends App{
	val json = """{
	"name" : "Adam Slodowy",
	"active": "true",
	"roles" : [ "teacher", "admin" ],
	"lessons" : [ { "id": 1 }, { "id": 2 } ],
	"security" : { "id" : 123, "login": "adams" }
	}"""
	val adam = JsonElement.parse(json).get
	case class Lesson(teacher: String, id: Int, name: String, active : Boolean = true)
	val lesson = Lesson(adam.name, adam.lessons.at(1).id, adam.lessons.at(1).name, adam.active)
	// will create Lesson("Adam Slodowy", 2, "", true ) - see the implicit conversions
	}
	trait JsonElement extends Dynamic{ self =>
	def selectDynamic(field: String) : JsonElement = EmptyElement
	def applyDynamic(field: String)(i: Int) : JsonElement = EmptyElement
	def toList : List[String] = sys.error(s"$this is not a list.")
	def asString: String = sys.error(s"$this has no string representation.")
	def length$ : Int = sys.error(s"$this has no length")
	}
	object JsonElement{
	def ^(s: String) = {
	require(!s.isEmpty, "Element is empty")
	s
	}
	implicit def toString(e: JsonElement) : String = e.asString
	implicit def toBoolean(e: JsonElement) : Boolean = (^(e.asString)).toBoolean
	implicit def toBigDecimal(e: JsonElement) : BigDecimal = BigDecimal(^(e.asString))
	implicit def toDouble(e: JsonElement) : Double = ^(e.asString).toDouble
	implicit def toFloat(e: JsonElement) : Float = ^(e.asString).toFloat
	implicit def toByte(e: JsonElement) : Byte = ^(e.asString).stripSuffix(".0").toByte
	implicit def toShort(e: JsonElement) : Short = ^(e.asString).stripSuffix(".0").toShort
	implicit def toInt(e: JsonElement) : Int = ^(e.asString).stripSuffix(".0").toInt
	implicit def toLong(e: JsonElement) : Long = ^(e.asString).stripSuffix(".0").toLong
	implicit def toList(e: JsonElement) : List[String] = e.toList
	def parse(json: String) = JSON.parseFull(json) map (JsonElement(_))
	def apply(any : Any) : JsonElement = any match {
	case x : Seq[Any] => new ArrayElement(x)
	case x : Map[String, Any] => new ComplexElement(x)
	case x => new PrimitiveElement(x)
	}
	}
	case class PrimitiveElement(x: Any) extends JsonElement{
	override def asString = x.toString
	}
	case object EmptyElement extends JsonElement{
	override def asString = ""
	override def toList = Nil
	}
	case class ArrayElement(private val x: Seq[Any]) extends JsonElement{
	private lazy val elements = x.map((JsonElement(_))).toArray
	override def applyDynamic(field: String)(i: Int) : JsonElement = elements.lift(i).getOrElse(EmptyElement)
	override def toList : List[String] = elements map (_.asString) toList
	override def length$ : Int = elements.length
	}
	case class ComplexElement(private val fields : Map[String, Any]) extends JsonElement{
	override def selectDynamic(field: String) : JsonElement = fields.get(field) map(JsonElement(_)) getOrElse(EmptyElement)
	}

view raw Json.scala hosted with ❤ by GitHub

The simplest Async Scala Http Client working with 2.10

This client is not the most efficient or the most async but it works and I am using it for testing my apps. Please feel free to copy/paste/reuse at your own risk.

	import concurrent.{Await, ExecutionContext, Future}
	import java.net.{HttpURLConnection, URL}
	import io.Source
	import concurrent.duration.FiniteDuration
	case class HttpResponse(code : Int, body: String, headers: Map[String, List[String]])
	case class RequestBody(body: String, contentType: String = "text/plain")
	object RequestBody{
	implicit def toRB(json: String) = RequestBody(json, contentType = "application/json")
	}
	class Http(baseUrl : String, cookie: Option[String] = None)(implicit ec: ExecutionContext, encoding: String="UTF-8"){
	def setCookie(cookie: String) = {
	new Http(baseUrl, Some(cookie))
	}
	import collection.JavaConverters._
	def get(path : String ) : Future[HttpResponse] = doRequest("GET", path)
	def post(path : String, requestBody: RequestBody ) : Future[HttpResponse] = doRequest("POST", path, Option(requestBody))
	def put(path : String, requestBody: RequestBody ) : Future[HttpResponse] = doRequest("PUT", path, Option(requestBody))
	def delete(path : String ) : Future[HttpResponse] = doRequest("DELETE", path)
	def doRequest(method: String, path: String, requestBody: Option[RequestBody] = None): Future[HttpResponse] = Future {
	val con = new URL(baseUrl + path).openConnection().asInstanceOf[HttpURLConnection]
	try {
	con.setDoInput(true)
	con.setInstanceFollowRedirects(false)
	cookie.foreach(cookie => con.setRequestProperty("Cookie", cookie))
	con.setRequestMethod(method)
	requestBody foreach{ requestBody=>
	con.setRequestProperty("Content-Type", s"${requestBody.contentType}; charset=$encoding")
	con.setDoOutput(true)
	val out = con.getOutputStream
	out.write(requestBody.body.getBytes(encoding))
	out.flush()
	out.close()
	}
	val headers = con.getHeaderFields.asScala.mapValues(_.asScala.toList).toMap - null
	val body = Source.fromInputStream(con.getInputStream).getLines() mkString ("\n")
	HttpResponse(con.getResponseCode, body, headers)
	} finally {
	con.disconnect()
	}
	}
	}

view raw Http.scala hosted with ❤ by GitHub