Migrate to spray-json library

build.sbt

@@ -41,6 +41,7 @@ lazy val root = (project in file("."))
       "org.scala-lang" % "scala-library" % Versions.scala,
       "org.scala-lang" % "scala-compiler" % Versions.scala,
       "org.scala-lang.modules" %% "scala-parser-combinators" % Versions.scalaParsers,
+      "io.spray" %%  "spray-json" % Versions.sprayJson,
       "org.scalaz" %% "scalaz-core" % Versions.scalaz,
       "com.novocode" % "junit-interface" % "0.11" % "test",
       "org.scalacheck" %% "scalacheck" % "1.13.4" % "test",

project/Versions.scala

@@ -3,4 +3,5 @@ object Versions {
   val scalaz = "7.2.20"
   val scalaParsers = "1.1.0"
   val idea = "2019.1"
+  val sprayJson = "1.3.5"
 }

src/main/resources/META-INF/plugin.xml

@@ -1,7 +1,7 @@
 <idea-plugin version="2">
   <id>org.psliwa.idea.composer</id>
   <name>PHP composer.json support</name>
-  <version>1.0.27</version>
+  <version>1.0.27-spray-json</version>
   <vendor email="me@psliwa.org" url="https://github.com/psliwa/idea-composer-plugin">psliwa</vendor>
 
     <description><![CDATA[

src/main/scala/org/psliwa/idea/composerJson/composer/parsers/JsonParsers.scala

@@ -2,10 +2,12 @@ package org.psliwa.idea.composerJson.composer.parsers
 
 import org.psliwa.idea.composerJson.composer._
 import org.psliwa.idea.composerJson.util.TryMonoid
-import scala.util.parsing.json.{JSONArray, JSONObject, JSON}
-import scala.util.{Success, Failure, Try}
+import spray.json._
+
+import scala.util.{Failure, Success, Try}
 import scalaz._
 import Scalaz._
+import org.psliwa.idea.composerJson.util.parsers.JSON
 
 object JsonParsers {
 
@@ -15,39 +17,39 @@ object JsonParsers {
 
   def parsePackageNames(data: String): Try[Seq[String]] = {
     val packages = for {
-      result <- JSON.parseRaw(data)
+      result <- JSON.parse(data)
       o <- tryJsonObject(result)
-      packageNames <- o.obj.get("packageNames")
+      packageNames <- o.fields.get("packageNames")
       packageNames <- tryJsonArray(packageNames)
-    } yield packageNames.list.map(_.toString)
+    } yield packageNames.elements.flatMap(tryJsonString)
 
     packages.map(Try(_)).getOrElse(Failure(new ParseException()))
   }
 
-  private def tryJsonObject(a: Any): Option[JSONObject] = a match {
-    case a@JSONObject(_) => Some(a)
+  private def tryJsonObject(a: JsValue): Option[JsObject] = a match {
+    case a@JsObject(_) => Some(a)
     case _ => None
   }
 
-  private def tryJsonArray(a: Any): Option[JSONArray] = a match {
-    case a@JSONArray(_) => Some(a)
+  private def tryJsonArray(a: JsValue): Option[JsArray] = a match {
+    case a@JsArray(_) => Some(a)
     case _ => None
   }
 
-  private def tryJsonString(a: Any): Option[String] = a match {
-    case a: String => Some(a)
+  private def tryJsonString(a: JsValue): Option[String] = a match {
+    case JsString(a) => Some(a)
     case _ => None
   }
 
   def parseVersions(data: String): Try[Seq[String]] = {
     val versions = for {
-      result <- JSON.parseRaw(data)
+      result <- JSON.parse(data)
       o <- tryJsonObject(result)
-      pkg <- o.obj.get("package")
+      pkg <- o.fields.get("package")
       pkg <- tryJsonObject(pkg)
-      versions <- pkg.obj.get("versions")
+      versions <- pkg.fields.get("versions")
       versions <- tryJsonObject(versions)
-    } yield versions.obj.keys.toList
+    } yield versions.fields.keys.toList
 
     versions.map(Try(_)).getOrElse(Failure(new ParseException()))
   }
@@ -56,11 +58,11 @@ object JsonParsers {
     import scalaz.Scalaz._
 
     def parse(property: String, dev: Boolean) = for {
-      result <- JSON.parseRaw(data)
+      result <- JSON.parse(data)
       o <- tryJsonObject(result)
-      packagesElement <- o.obj.get(property)
+      packagesElement <- o.fields.get(property)
       packagesArray <- tryJsonArray(packagesElement)
-      packages <- packagesArray.list.traverse(createLockPackage(dev))
+      packages <- packagesArray.elements.traverse(createLockPackage(dev))
     } yield packages
 
     val packages = for {
@@ -74,23 +76,23 @@ object JsonParsers {
     }
   }
 
-  private def createLockPackage(dev: Boolean)(maybeJsonObject: Any): Option[ComposerPackage] = {
+  private def createLockPackage(dev: Boolean)(maybeJsonObject: JsValue): Option[ComposerPackage] = {
     for {
       jsonObject <- tryJsonObject(maybeJsonObject)
-      name <- jsonObject.obj.get("name").map(_.toString)
-      version <- jsonObject.obj.get("version").map(_.toString)
-      homepage = jsonObject.obj.get("homepage").map(_.toString)
+      name <- jsonObject.fields.get("name").flatMap(tryJsonString)
+      version <- jsonObject.fields.get("version").flatMap(tryJsonString)
+      homepage = jsonObject.fields.get("homepage").flatMap(tryJsonString)
     } yield ComposerPackage(name, version, dev, homepage)
   }
 
   private def parsePackagesFromPackagesJson(data: String): Try[RepositoryPackages] = {
-    def getPackagesFrom(json: Any): Option[Map[String,Seq[String]]] = {
+    def getPackagesFrom(json: JsValue): Option[Map[String,Seq[String]]] = {
       val packages: Map[String,Seq[String]] = (for {
         obj <- tryJsonObject(json).toList
-        packageName <- obj.obj.keys
-        packageObject <- obj.obj.get(packageName)
+        packageName <- obj.fields.keys
+        packageObject <- obj.fields.get(packageName)
         packageObject <- tryJsonObject(packageObject)
-        versions <- Option(packageObject.obj.keys.toSeq)
+        versions <- Option(packageObject.fields.keys.toSeq)
       } yield packageName -> versions).toMap
 
       Option(packages)
@@ -100,32 +102,32 @@ object JsonParsers {
 
     val packages = for {
       root <- maybeRoot
-      packagesElement <- root.obj.get("packages")
+      packagesElement <- root.fields.get("packages")
       packages <- getPackagesFrom(packagesElement)
     } yield packages
 
     val includes = for {
       root <- maybeRoot.toList
-      includesElement <- root.obj.get("includes").toList
+      includesElement <- root.fields.get("includes").toList
       includesElement <- tryJsonObject(includesElement).toList
-      include <- includesElement.obj.keys.toList
+      include <- includesElement.fields.keys.toList
     } yield include
 
     packages.map(pkgs => Try(RepositoryPackages(pkgs, includes))).getOrElse(tryMonoid.zero)
   }
 
-  private def parse(data: String): Option[JSONObject] = for {
-    result <- JSON.parseRaw(data)
+  private def parse(data: String): Option[JsObject] = for {
+    result <- JSON.parse(data)
     o <- tryJsonObject(result)
   } yield o
 
   private def parsePackageFromComposerJson(data: String): Try[RepositoryPackages] = {
     (for {
       root <- parse(data)
-      name <- root.obj.get("name")
+      name <- root.fields.get("name")
       name <- tryJsonString(name)
       versions <- (for {
-        version <- root.obj.get("version")
+        version <- root.fields.get("version")
         version <- tryJsonString(version)
       } yield version).map(Seq(_)).orElse(Some(Seq.empty))
     } yield RepositoryPackages(Map(name -> versions), Seq.empty)).map(Success(_)).getOrElse(tryMonoid.zero)