initial commit

Author: colinrgodsey

README.md

@@ -0,0 +1,7 @@
+ScalaJSON.settings
+
+lazy val jsonJs = Project("scala-json", file("scalajs"))
+    .enablePlugins(ScalaJSPlugin)
+    .settings(ScalaJSON.jsSettings: _*)
+
+lazy val json = project.aggregate(jsonJs).settings(ScalaJSON.settings: _*).aggregate(jsonJs)

build.sbt

@@ -0,0 +1,69 @@
+import sbt.Keys._
+import sbt._
+import org.scalajs.sbtplugin.ScalaJSPlugin
+import org.scalajs.sbtplugin.ScalaJSPlugin.autoImport._
+import sbt.dsl._
+
+object Repository {
+  val host = "artifactory.mediamath.com"
+  val artifactory = s"https://$host/artifactory/"
+  val snapshots = s"${artifactory}libs-snapshot"
+  val releases = s"${artifactory}libs-release"
+  val remote = s"${artifactory}remote-repos"
+  val pluginSnapshots = s"${artifactory}sbt-plugins-snapshot-local"
+  val pluginRelease = s"${artifactory}sbt-plugins-release-local"
+
+  val snapshotRepo = "snapshots" at Repository.snapshots
+  val releaseRepo = "releases" at Repository.releases
+  val remoteRepo = "remote" at Repository.remote
+
+  def repo(isSnapshot: Boolean) = if (isSnapshot) Repository.snapshots else Repository.releases
+  def publishTo(isSnapshot: Boolean) = repo(isSnapshot) + "-local"
+  def globalPublishTo(isSnapshot: Boolean) = repo(isSnapshot) + "-global"
+  def userCredentials = (Path.userHome / ".ivy2" / "credentials" ** "*").filter(_.isFile).get.map(Credentials(_))
+}
+
+object ScalaJSON {
+  val commonSettings = Seq(
+    version := "0.1",
+    scalaVersion := "2.11.5",
+    organization := "com.mediamath",
+    organizationName := "MediaMath, Inc",
+    organizationHomepage := Some(url("http://www.mediamath.com")),
+    credentials ++= Repository.userCredentials,
+    publishMavenStyle := true,
+    crossPaths := true,
+    publishTo := Some("publish" at Repository.globalPublishTo(isSnapshot.value)),
+    publishArtifact in Test := false,
+
+    scalacOptions ++= Seq("-deprecation", "-language:_", "-unchecked", "-Xlint",
+      "-Xlog-free-terms", "-target:jvm-1.7", "-encoding", "UTF-8"),
+
+    libraryDependencies <++= scalaVersion { x =>
+      Seq(
+        "org.scala-lang" % "scala-reflect" % x,
+        "org.scala-lang" % "scala-compiler" % x
+      )
+    },
+
+    libraryDependencies ++= Seq(
+      "com.lihaoyi" %%% "utest" % "0.3.0" % "test",
+      "com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.4.1"
+    ),
+
+    testFrameworks += new TestFramework("utest.runner.Framework")
+  )
+
+  val settings = commonSettings ++ Seq(
+    name := "scala-json"
+  )
+
+  val jsSettings = commonSettings ++ Seq(
+    name := "scala-json",
+
+    unmanagedSourceDirectories in Compile +=
+        (baseDirectory in ThisBuild).value / "src" / "main" / "scala",
+    unmanagedSourceDirectories in Test +=
+        (baseDirectory in ThisBuild).value / "src" / "test" / "scala"
+  )
+}

project/ScalaJSON.scala

@@ -0,0 +1,2 @@
+sbt.version=0.13.7
+

project/build.properties

@@ -0,0 +1 @@
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "0.6.0")

project/plugins.sbt

@@ -0,0 +1,13 @@
+package json
+
+import scalajs.js
+
+object JSImplicits {
+  implicit class JSAnyExt(val value: js.Any) extends AnyVal {
+    def toJValue = JSJValue from value
+  }
+
+  implicit class JSValueExt(val value: JValue) extends AnyVal {
+    def toJS = JSJValue toJS value
+  }
+}

scalajs/src/main/scala/json/JSImplicits.scala

@@ -0,0 +1,39 @@
+package json
+
+import scala.scalajs.js
+import json.internal.DefaultJVMShadowContext.{ VMContext => JVMContext }
+
+import js.JSConverters._
+
+object JSJValue {
+  def from(v: Any): JValue = v match {
+    case x: JValue => x
+    case seq0: js.Array[Any] =>
+      val seq: Seq[Any] = seq0
+      val jvals: Seq[JValue] = seq.map(JSJValue.from)
+
+      JArray(jvals)
+    case x0: js.Object =>
+      val x = x0.asInstanceOf[js.Dynamic]
+      val seq = (js.Object keys x0).toSeq.map { key =>
+        val value = JSJValue from x.selectDynamic(key)
+        JString(key) -> value
+      }
+      JObject(seq: _*)
+    case x: String => JString(x)
+    case x         => JVMContext.fromAny(x)
+  }
+
+  def toJS(from: JValue): js.Any = from match {
+    case x: JObject =>
+      val vals = for ((JString(key), value) <- x.iterator)
+        yield key -> toJS(value)
+
+      vals.toMap.toJSDictionary
+    case JArray(values) =>
+      values.map(toJS).toJSArray
+    case JUndefined => js.undefined
+    case JNull      => null
+    case x          => x.value.asInstanceOf[js.Any] //assumed to be a primitive here
+  }
+}

scalajs/src/main/scala/json/JSJValue.scala

@@ -0,0 +1,21 @@
+package json.shadow
+
+import json.internal.DefaultJVMShadowContext
+import json.{ JSJValue, JValue }
+
+import scalajs.js
+
+object VMContext {
+  def fromString(str: String): JValue = {
+    //TODO: use parse 2nd arg for inline wrapper!
+    val parsed = js.Dynamic.global.JSON.parse(str)
+
+    JSJValue.from(parsed)
+  }
+
+  def fromAny(value: Any): JValue = JSJValue.from(value)
+
+  trait JValueCompanionBase extends DefaultJVMShadowContext.VMContext.JValueCompanionBase
+
+  trait JValueBase extends DefaultJVMShadowContext.VMContext.JValueBase
+}

scalajs/src/main/scala/json/shadow/VMContext.scala

@@ -0,0 +1,114 @@
+package json
+
+import scala.collection.generic.{ CanBuildFrom, GenericCompanion }
+import scala.collection.mutable.Builder
+import scala.collection.immutable.VectorBuilder
+import scala.collection.{ IterableLike, immutable }
+import java.util.UUID
+
+object JArray { //extends GenericCompanion[scala.collection.immutable.Iterable] {
+  //def apply(values: IndexedSeq[JValue]): JArray = new JArray(values)
+
+  //def unapply(obj: JArray): Option[IndexedSeq[JValue]] = Some(obj.values)
+
+  lazy val empty = apply(IndexedSeq.empty)
+
+  def newCanBuildFrom = new CanBuildFrom[TraversableOnce[JValue], JValue, JArray] {
+    def apply(from: TraversableOnce[JValue]) = newJArrayBuilder // ++= from
+    def apply() = newJArrayBuilder
+  }
+
+  implicit def canBuildFrom: CanBuildFrom[TraversableOnce[JValue], JValue, JArray] =
+    newCanBuildFrom
+
+  def newJArrayBuilder: Builder[JValue, JArray] = new JArrayBuilder
+
+  def apply(seq: TraversableOnce[JValue]): JArray = new JArray(seq.toIndexedSeq)
+  //def apply[T <: JValue](x: T, xN: T*): JArray = apply(x +: xN)
+
+  class JArrayBuilder extends Builder[JValue, JArray] {
+    val builder = new VectorBuilder[JValue]
+
+    def +=(item: JValue): this.type = {
+      builder += item
+      this
+    }
+
+    def result: JArray = {
+      JArray(builder.result)
+    }
+
+    def clear() {
+      builder.clear
+    }
+  }
+
+  def newBuilder[A]: Builder[A, immutable.Iterable[A]] =
+    newJArrayBuilder.asInstanceOf[Builder[A, immutable.Iterable[A]]]
+}
+
+final case class JArray(override val values: IndexedSeq[JValue]) extends JValue with scala.collection.immutable.Iterable[JValue] with IterableLike[JValue, JArray] {
+  lazy val uuid = UUID.randomUUID.toString
+
+  def toJString: JString = JString("array " + uuid) //this... should be different
+  def toJNumber: JNumber = JNaN
+  def toJBoolean: JBoolean = JTrue
+  //override def toObject
+
+  def length = values.length
+
+  def iterator: Iterator[JValue] = values.iterator
+
+  def value = values.map(_.value)
+
+  //override def companion: GenericCompanion[scala.collection.immutable.Iterable] = JArray
+  override def newBuilder = JArray.newJArrayBuilder
+
+  override def toSeq = values
+  override def seq = this
+
+  override def jValue = this
+  override def toJArray: JArray = this
+  //override def keys = (0 until values.length).map(JNumber(_)).toSet
+
+  override def jObject: JObject = throw GenericJSONException("Expected JObject")
+  override def jArray: JArray = this
+  override def jNumber: JNumber = throw GenericJSONException("Expected JNumber")
+  override def jString: JString = throw GenericJSONException("Expected JString")
+  override def jBoolean: JBoolean = throw GenericJSONException("Expected JBoolean")
+
+  override def toString = toJSONString
+
+  def apply(key: JNumber): JValue = apply(key: JValue)
+
+  override def apply(key: JValue): JValue = {
+    val jNum = key.toJNumber
+    val jInt = jNum.num.toInt
+
+    if (jNum.num != jInt) JUndefined
+    else if (jInt < 0) JUndefined
+    else if (jInt >= values.length) JUndefined
+    else values(jInt)
+  }
+
+  def ++(that: JArray): JArray =
+    JArray(values ++ that.values)
+
+  def toJSONStringBuilder(settings: JSONBuilderSettings,
+    lvl: Int): StringBuilder = {
+    val out = new StringBuilder
+
+    out.append("[")
+
+    var isFirst = true
+    values foreach { v =>
+      if (!isFirst) out.append("," + settings.spaceString)
+
+      out append v.toJSONStringBuilder(settings)
+
+      isFirst = false
+    }
+
+    out.append("]")
+  }
+}