From ef1ec99bd0ba79fe1fafd60ffb953cd10494efd9 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Wed, 4 Mar 2015 04:31:31 -0500 Subject: [PATCH] Implement pickler for UpdateReport. #1763 --- build.sbt | 2 +- ivy/src/main/scala/sbt/Artifact.scala | 70 +++++++++ ivy/src/main/scala/sbt/Configuration.scala | 5 + ivy/src/main/scala/sbt/CrossVersion.scala | 37 +++++ ivy/src/main/scala/sbt/DatePicklers.scala | 35 +++++ ivy/src/main/scala/sbt/FileMapPicklers.scala | 22 +++ ivy/src/main/scala/sbt/IvyInterface.scala | 4 + ivy/src/main/scala/sbt/JsonUtil.scala | 84 ++--------- ivy/src/main/scala/sbt/ModuleID.scala | 3 + ivy/src/main/scala/sbt/PairPicklers.scala | 44 ++++++ ivy/src/main/scala/sbt/UpdateReport.scala | 146 ++++++++++++++----- ivy/src/test/scala/DMSerializationSpec.scala | 67 +++++++++ project/Dependencies.scala | 4 +- 13 files changed, 411 insertions(+), 112 deletions(-) create mode 100644 ivy/src/main/scala/sbt/DatePicklers.scala create mode 100644 ivy/src/main/scala/sbt/FileMapPicklers.scala create mode 100644 ivy/src/main/scala/sbt/PairPicklers.scala create mode 100644 ivy/src/test/scala/DMSerializationSpec.scala diff --git a/build.sbt b/build.sbt index 320c31fed..7b79a8b20 100644 --- a/build.sbt +++ b/build.sbt @@ -262,7 +262,7 @@ lazy val ivyProj = (project in file("ivy")). settings(baseSettings: _*). settings( name := "Ivy", - libraryDependencies ++= Seq(ivy, jsch, json4sNative, jawnParser, jawnJson4s), + libraryDependencies ++= Seq(ivy, jsch, sbtSerialization), testExclusive) // Runner for uniform test interface diff --git a/ivy/src/main/scala/sbt/Artifact.scala b/ivy/src/main/scala/sbt/Artifact.scala index 325ef7b6b..f24c93267 100644 --- a/ivy/src/main/scala/sbt/Artifact.scala +++ b/ivy/src/main/scala/sbt/Artifact.scala @@ -5,6 +5,7 @@ package sbt import java.io.File import java.net.URL +import sbt.serialization._ final case class Artifact(name: String, `type`: String, extension: String, classifier: Option[String], configurations: Iterable[Configuration], url: Option[URL], extraAttributes: Map[String, String]) { def extra(attributes: (String, String)*) = Artifact(name, `type`, extension, classifier, configurations, url, extraAttributes ++ ModuleID.checkE(attributes)) @@ -71,4 +72,73 @@ object Artifact { def classifierType(classifier: String): String = classifierTypeMap.getOrElse(classifier.stripPrefix(TestsClassifier + "-"), DefaultType) def classified(name: String, classifier: String): Artifact = Artifact(name, classifierType(classifier), DefaultExtension, Some(classifier), classifierConf(classifier) :: Nil, None) + + private val optStringPickler = implicitly[Pickler[Option[String]]] + private val optStringUnpickler = implicitly[Unpickler[Option[String]]] + private val vectorConfigurationPickler = implicitly[Pickler[Vector[Configuration]]] + private val vectorConfigurationUnpickler = implicitly[Unpickler[Vector[Configuration]]] + private val stringStringMapPickler = implicitly[Pickler[Map[String, String]]] + private val stringStringMapUnpickler = implicitly[Unpickler[Map[String, String]]] + + implicit val pickler: Pickler[Artifact] = new Pickler[Artifact] { + val tag = implicitly[FastTypeTag[Artifact]] + val stringTag = implicitly[FastTypeTag[String]] + val optionStringTag = implicitly[FastTypeTag[Option[String]]] + val vectorConfigurationTag = implicitly[FastTypeTag[Vector[Configuration]]] + val stringStringMapTag = implicitly[FastTypeTag[Map[String, String]]] + def pickle(a: Artifact, builder: PBuilder): Unit = { + builder.pushHints() + builder.hintTag(tag) + builder.beginEntry(a) + builder.putField("name", { b => + b.hintTag(stringTag) + stringPickler.pickle(a.name, b) + }) + builder.putField("type", { b => + b.hintTag(stringTag) + stringPickler.pickle(a.`type`, b) + }) + builder.putField("extension", { b => + b.hintTag(stringTag) + stringPickler.pickle(a.extension, b) + }) + builder.putField("classifier", { b => + b.hintTag(optionStringTag) + optStringPickler.pickle(a.classifier, b) + }) + builder.putField("configurations", { b => + b.hintTag(vectorConfigurationTag) + vectorConfigurationPickler.pickle(a.configurations.toVector, b) + }) + builder.putField("url", { b => + b.hintTag(optionStringTag) + optStringPickler.pickle(a.url map { _.toString }, b) + }) + builder.putField("extraAttributes", { b => + b.hintTag(stringStringMapTag) + stringStringMapPickler.pickle(a.extraAttributes, b) + }) + builder.endEntry() + builder.popHints() + } + } + implicit val unpickler: Unpickler[Artifact] = new Unpickler[Artifact] { + val tag = implicitly[FastTypeTag[Artifact]] + def unpickle(tpe: String, reader: PReader): Any = { + reader.pushHints() + reader.hintTag(tag) + reader.beginEntry() + val name = stringPickler.unpickleEntry(reader.readField("name")).asInstanceOf[String] + val tp = stringPickler.unpickleEntry(reader.readField("type")).asInstanceOf[String] + val extension = stringPickler.unpickleEntry(reader.readField("extension")).asInstanceOf[String] + val classifier = optStringUnpickler.unpickleEntry(reader.readField("classifier")).asInstanceOf[Option[String]] + val configurations = vectorConfigurationUnpickler.unpickleEntry(reader.readField("configurations")).asInstanceOf[Vector[Configuration]] + val u = optStringUnpickler.unpickleEntry(reader.readField("url")).asInstanceOf[Option[String]] map { new URL(_) } + val extraAttributes = stringStringMapUnpickler.unpickleEntry(reader.readField("extraAttributes")).asInstanceOf[Map[String, String]] + val result = Artifact(name, tp, extension, classifier, configurations, u, extraAttributes) + reader.endEntry() + reader.popHints() + result + } + } } diff --git a/ivy/src/main/scala/sbt/Configuration.scala b/ivy/src/main/scala/sbt/Configuration.scala index 58b5073b8..d666b32bc 100644 --- a/ivy/src/main/scala/sbt/Configuration.scala +++ b/ivy/src/main/scala/sbt/Configuration.scala @@ -3,6 +3,8 @@ */ package sbt +import sbt.serialization._ + object Configurations { def config(name: String) = new Configuration(name) def default: Seq[Configuration] = defaultMavenConfigurations @@ -61,3 +63,6 @@ final case class Configuration(name: String, description: String, isPublic: Bool def hide = Configuration(name, description, false, extendsConfigs, transitive) override def toString = name } +object Configuration { + implicit val pickler: Pickler[Configuration] with Unpickler[Configuration] = PicklerUnpickler.generate[Configuration] +} diff --git a/ivy/src/main/scala/sbt/CrossVersion.scala b/ivy/src/main/scala/sbt/CrossVersion.scala index da37da251..b17ac525c 100644 --- a/ivy/src/main/scala/sbt/CrossVersion.scala +++ b/ivy/src/main/scala/sbt/CrossVersion.scala @@ -1,6 +1,7 @@ package sbt import cross.CrossVersionUtil +import sbt.serialization._ final case class ScalaVersion(full: String, binary: String) @@ -35,6 +36,42 @@ object CrossVersion { override def toString = "Full" } + private val disabledTag = implicitly[FastTypeTag[Disabled.type]] + private val binaryTag = implicitly[FastTypeTag[Binary]] + private val fullTag = implicitly[FastTypeTag[Full]] + implicit val pickler: Pickler[CrossVersion] = new Pickler[CrossVersion] { + val tag = implicitly[FastTypeTag[CrossVersion]] + def pickle(a: CrossVersion, builder: PBuilder): Unit = { + builder.pushHints() + builder.hintTag(a match { + case Disabled => disabledTag + case x: Binary => binaryTag + case x: Full => fullTag + }) + builder.beginEntry(a) + builder.endEntry() + builder.popHints() + } + } + implicit val unpickler: Unpickler[CrossVersion] = new Unpickler[CrossVersion] { + val tag = implicitly[FastTypeTag[CrossVersion]] + def unpickle(tpe: String, reader: PReader): Any = { + reader.pushHints() + reader.hintTag(tag) + val tpeStr = reader.beginEntry() + val tpe = scala.pickling.FastTypeTag(tpeStr) + // sys.error(tpe.toString) + val result = tpe match { + case t if t == disabledTag => Disabled + case t if t == binaryTag => binary + case t if t == fullTag => full + } + reader.endEntry() + reader.popHints() + result + } + } + /** Cross-versions a module with the full version (typically the full Scala version). */ def full: CrossVersion = new Full(idFun) diff --git a/ivy/src/main/scala/sbt/DatePicklers.scala b/ivy/src/main/scala/sbt/DatePicklers.scala new file mode 100644 index 000000000..166f50f2d --- /dev/null +++ b/ivy/src/main/scala/sbt/DatePicklers.scala @@ -0,0 +1,35 @@ +package sbt + +import sbt.serialization._ +import java.{ util => ju } + +private[sbt] object DatePicklers { + private val longTag = implicitly[FastTypeTag[Long]] + implicit val datePickler: Pickler[ju.Date] = new Pickler[ju.Date] { + val tag = implicitly[FastTypeTag[ju.Date]] + def pickle(a: ju.Date, builder: PBuilder): Unit = { + builder.pushHints() + builder.hintTag(tag) + builder.beginEntry(a) + builder.putField("value", { b => + b.hintTag(longTag) + longPickler.pickle(a.getTime, b) + }) + builder.endEntry() + builder.popHints() + } + } + implicit val dateUnpickler: Unpickler[ju.Date] = new Unpickler[ju.Date] { + val tag = implicitly[FastTypeTag[ju.Date]] + def unpickle(tpe: String, reader: PReader): Any = { + reader.pushHints() + reader.hintTag(tag) + reader.beginEntry() + val a0 = longPickler.unpickleEntry(reader.readField("value")).asInstanceOf[Long] + val result = new ju.Date(a0) + reader.endEntry() + reader.popHints() + result + } + } +} diff --git a/ivy/src/main/scala/sbt/FileMapPicklers.scala b/ivy/src/main/scala/sbt/FileMapPicklers.scala new file mode 100644 index 000000000..8a7314118 --- /dev/null +++ b/ivy/src/main/scala/sbt/FileMapPicklers.scala @@ -0,0 +1,22 @@ +package sbt + +import java.io.File +import sbt.serialization._ +import java.net.URI + +object FileMapPicklers { + implicit def fileMapPickler[A: Pickler: Unpickler: FastTypeTag]: Pickler[Map[File, A]] with Unpickler[Map[File, A]] = new Pickler[Map[File, A]] with Unpickler[Map[File, A]] { + val tag = implicitly[FastTypeTag[Map[File, A]]] + val stringAMapPickler = implicitly[Pickler[Map[String, A]]] + val stringAMapUnpickler = implicitly[Unpickler[Map[String, A]]] + + def pickle(m: Map[File, A], builder: PBuilder): Unit = + stringAMapPickler.pickle(Map(m.toSeq map { case (k, v) => (k.toURI.toASCIIString, v) }: _*), builder) + + def unpickle(tpe: String, reader: PReader): Any = + Map(stringAMapUnpickler.unpickle(tpe, reader).asInstanceOf[Map[String, A]].toSeq map { + case (k, v) => + (new File(new URI(k)), v) + }: _*).asInstanceOf[Map[File, A]] + } +} diff --git a/ivy/src/main/scala/sbt/IvyInterface.scala b/ivy/src/main/scala/sbt/IvyInterface.scala index e4c2e8e46..3b54c684c 100644 --- a/ivy/src/main/scala/sbt/IvyInterface.scala +++ b/ivy/src/main/scala/sbt/IvyInterface.scala @@ -8,6 +8,7 @@ import java.net.{ URI, URL } import scala.xml.NodeSeq import org.apache.ivy.plugins.resolver.{ DependencyResolver, IBiblioResolver } import org.apache.ivy.util.url.CredentialsStore +import sbt.serialization._ /** Additional information about a project module */ final case class ModuleInfo(nameFormal: String, description: String = "", homepage: Option[URL] = None, startYear: Option[Int] = None, licenses: Seq[(String, URL)] = Nil, organizationName: String = "", organizationHomepage: Option[URL] = None, scmInfo: Option[ScmInfo] = None, developers: Seq[Developer] = Seq()) { @@ -26,6 +27,9 @@ final case class Developer(id: String, name: String, email: String, url: URL) /** Rule to exclude unwanted dependencies pulled in transitively by a module. */ final case class ExclusionRule(organization: String = "*", name: String = "*", artifact: String = "*", configurations: Seq[String] = Nil) +object ExclusionRule { + implicit val pickler: Pickler[ExclusionRule] with Unpickler[ExclusionRule] = PicklerUnpickler.generate[ExclusionRule] +} final case class ModuleConfiguration(organization: String, name: String, revision: String, resolver: Resolver) object ModuleConfiguration { diff --git a/ivy/src/main/scala/sbt/JsonUtil.scala b/ivy/src/main/scala/sbt/JsonUtil.scala index c1e03d1d5..ddd126555 100644 --- a/ivy/src/main/scala/sbt/JsonUtil.scala +++ b/ivy/src/main/scala/sbt/JsonUtil.scala @@ -2,22 +2,17 @@ package sbt import java.io.File import java.net.URL -import org.json4s._ import org.apache.ivy.core import core.module.descriptor.ModuleDescriptor +import sbt.serialization._ private[sbt] object JsonUtil { def parseUpdateReport(md: ModuleDescriptor, path: File, cachedDescriptor: File, log: Logger): UpdateReport = { - import org.json4s._ - implicit val formats = native.Serialization.formats(NoTypeHints) + - new ConfigurationSerializer + - new ArtifactSerializer + - new FileSerializer + - new URLSerializer try { - val json = jawn.support.json4s.Parser.parseFromFile(path) - fromLite(json.get.extract[UpdateReportLite], cachedDescriptor) + val s = IO.read(path, IO.utf8) + val lite = fromJsonString[UpdateReportLite](s).get + fromLite(lite, cachedDescriptor) } catch { case e: Throwable => log.error("Unable to parse mini graph: " + path.toString) @@ -26,12 +21,7 @@ private[sbt] object JsonUtil { } def writeUpdateReport(ur: UpdateReport, graphPath: File): Unit = { - implicit val formats = native.Serialization.formats(NoTypeHints) + - new ConfigurationSerializer + - new ArtifactSerializer + - new FileSerializer - import native.Serialization.write - val str = write(toLite(ur)) + val str = toJsonString(toLite(ur)) IO.write(graphPath, str, IO.utf8) } def toLite(ur: UpdateReport): UpdateReportLite = @@ -60,61 +50,11 @@ private[sbt] object JsonUtil { } private[sbt] case class UpdateReportLite(configurations: Seq[ConfigurationReportLite]) +private[sbt] object UpdateReportLite { + implicit val pickler: Pickler[UpdateReportLite] with Unpickler[UpdateReportLite] = PicklerUnpickler.generate[UpdateReportLite] +} + private[sbt] case class ConfigurationReportLite(configuration: String, details: Seq[OrganizationArtifactReport]) - -private[sbt] class URLSerializer extends CustomSerializer[URL](format => ( - { - case JString(s) => new URL(s) - }, - { - case x: URL => JString(x.toString) - } -)) - -private[sbt] class FileSerializer extends CustomSerializer[File](format => ( - { - case JString(s) => new File(s) - }, - { - case x: File => JString(x.toString) - } -)) - -private[sbt] class ConfigurationSerializer extends CustomSerializer[Configuration](format => ( - { - case JString(s) => new Configuration(s) - }, - { - case x: Configuration => JString(x.name) - } -)) - -private[sbt] class ArtifactSerializer extends CustomSerializer[Artifact](format => ( - { - case json: JValue => - implicit val fmt = format - Artifact( - (json \ "name").extract[String], - (json \ "type").extract[String], - (json \ "extension").extract[String], - (json \ "classifier").extract[Option[String]], - (json \ "configurations").extract[List[Configuration]], - (json \ "url").extract[Option[URL]], - (json \ "extraAttributes").extract[Map[String, String]] - ) - }, - { - case x: Artifact => - import DefaultJsonFormats.{ OptionWriter, StringWriter, mapWriter } - val optStr = implicitly[Writer[Option[String]]] - val mw = implicitly[Writer[Map[String, String]]] - JObject(JField("name", JString(x.name)) :: - JField("type", JString(x.`type`)) :: - JField("extension", JString(x.extension)) :: - JField("classifier", optStr.write(x.classifier)) :: - JField("configurations", JArray(x.configurations.toList map { x => JString(x.name) })) :: - JField("url", optStr.write(x.url map { _.toString })) :: - JField("extraAttributes", mw.write(x.extraAttributes)) :: - Nil) - } -)) +private[sbt] object ConfigurationReportLite { + implicit val pickler: Pickler[ConfigurationReportLite] with Unpickler[ConfigurationReportLite] = PicklerUnpickler.generate[ConfigurationReportLite] +} diff --git a/ivy/src/main/scala/sbt/ModuleID.scala b/ivy/src/main/scala/sbt/ModuleID.scala index c0e8670d5..10647dcad 100644 --- a/ivy/src/main/scala/sbt/ModuleID.scala +++ b/ivy/src/main/scala/sbt/ModuleID.scala @@ -6,6 +6,7 @@ package sbt import java.net.URL import sbt.mavenint.SbtPomExtraProperties +import sbt.serialization._ final case class ModuleID(organization: String, name: String, revision: String, configurations: Option[String] = None, isChanging: Boolean = false, isTransitive: Boolean = true, isForce: Boolean = false, explicitArtifacts: Seq[Artifact] = Nil, exclusions: Seq[ExclusionRule] = Nil, extraAttributes: Map[String, String] = Map.empty, crossVersion: CrossVersion = CrossVersion.Disabled) { override def toString: String = @@ -119,6 +120,8 @@ final case class ModuleID(organization: String, name: String, revision: String, def jar() = artifacts(Artifact(name)) } object ModuleID { + implicit val pickler: Pickler[ModuleID] with Unpickler[ModuleID] = PicklerUnpickler.generate[ModuleID] + /** Prefixes all keys with `e:` if they are not already so prefixed. */ def checkE(attributes: Seq[(String, String)]) = for ((key, value) <- attributes) yield if (key.startsWith("e:")) (key, value) else ("e:" + key, value) diff --git a/ivy/src/main/scala/sbt/PairPicklers.scala b/ivy/src/main/scala/sbt/PairPicklers.scala new file mode 100644 index 000000000..2229059f2 --- /dev/null +++ b/ivy/src/main/scala/sbt/PairPicklers.scala @@ -0,0 +1,44 @@ +package sbt + +import sbt.serialization._ + +private[sbt] object PairPicklers { + implicit def pairPickler[A1: FastTypeTag: Pickler: Unpickler, A2: FastTypeTag: Pickler: Unpickler](): Pickler[(A1, A2)] with Unpickler[(A1, A2)] = + new Pickler[(A1, A2)] with Unpickler[(A1, A2)] { + val a1Tag = implicitly[FastTypeTag[A1]] + val a2Tag = implicitly[FastTypeTag[A2]] + val tag = implicitly[FastTypeTag[(A1, A2)]] + val a1Pickler = implicitly[Pickler[A1]] + val a1Unpickler = implicitly[Unpickler[A1]] + val a2Pickler = implicitly[Pickler[A2]] + val a2Unpickler = implicitly[Unpickler[A2]] + + def pickle(a: (A1, A2), builder: PBuilder): Unit = { + builder.pushHints() + builder.hintTag(tag) + builder.beginEntry(a) + builder.putField("_1", { b => + b.hintTag(a1Tag) + a1Pickler.pickle(a._1, b) + }) + builder.putField("_2", { b => + b.hintTag(a2Tag) + a2Pickler.pickle(a._2, b) + }) + builder.endEntry() + builder.popHints() + } + + def unpickle(tpe: String, reader: PReader): Any = { + reader.pushHints() + reader.hintTag(tag) + reader.beginEntry() + val a0 = a1Unpickler.unpickleEntry(reader.readField("_1")).asInstanceOf[A1] + val a1 = a2Unpickler.unpickleEntry(reader.readField("_2")).asInstanceOf[A2] + val result = (a0, a1) + reader.endEntry() + reader.popHints() + result + } + } +} diff --git a/ivy/src/main/scala/sbt/UpdateReport.scala b/ivy/src/main/scala/sbt/UpdateReport.scala index 9487febef..672f6abc1 100644 --- a/ivy/src/main/scala/sbt/UpdateReport.scala +++ b/ivy/src/main/scala/sbt/UpdateReport.scala @@ -6,41 +6,7 @@ package sbt import java.io.File import java.net.URL import java.{ util => ju } - -/** - * Provides information about dependency resolution. - * It does not include information about evicted modules, only about the modules ultimately selected by the conflict manager. - * This means that for a given configuration, there should only be one revision for a given organization and module name. - * @param cachedDescriptor the location of the resolved module descriptor in the cache - * @param configurations a sequence containing one report for each configuration resolved. - * @param stats information about the update that produced this report - * @see sbt.RichUpdateReport - */ -final class UpdateReport(val cachedDescriptor: File, val configurations: Seq[ConfigurationReport], val stats: UpdateStats, private[sbt] val stamps: Map[File, Long]) { - @deprecated("Use the variant that provides timestamps of files.", "0.13.0") - def this(cachedDescriptor: File, configurations: Seq[ConfigurationReport], stats: UpdateStats) = - this(cachedDescriptor, configurations, stats, Map.empty) - - override def toString = "Update report:\n\t" + stats + "\n" + configurations.mkString - - /** All resolved modules in all configurations. */ - def allModules: Seq[ModuleID] = configurations.flatMap(_.allModules).distinct - - def retrieve(f: (String, ModuleID, Artifact, File) => File): UpdateReport = - new UpdateReport(cachedDescriptor, configurations map { _ retrieve f }, stats, stamps) - - /** Gets the report for the given configuration, or `None` if the configuration was not resolved.*/ - def configuration(s: String) = configurations.find(_.configuration == s) - - /** Gets the names of all resolved configurations. This `UpdateReport` contains one `ConfigurationReport` for each configuration in this list. */ - def allConfigurations: Seq[String] = configurations.map(_.configuration) - - private[sbt] def withStats(us: UpdateStats): UpdateReport = - new UpdateReport(this.cachedDescriptor, - this.configurations, - us, - this.stamps) -} +import sbt.serialization._ /** * Provides information about resolution of a single configuration. @@ -71,6 +37,9 @@ final class ConfigurationReport( def retrieve(f: (String, ModuleID, Artifact, File) => File): ConfigurationReport = new ConfigurationReport(configuration, modules map { _.retrieve((mid, art, file) => f(configuration, mid, art, file)) }, details, evicted) } +object ConfigurationReport { + implicit val pickler: Pickler[ConfigurationReport] with Unpickler[ConfigurationReport] = PicklerUnpickler.generate[ConfigurationReport] +} /** * OrganizationArtifactReport represents an organization+name entry in Ivy resolution report. @@ -93,6 +62,8 @@ final class OrganizationArtifactReport private[sbt] ( } } object OrganizationArtifactReport { + implicit val pickler: Pickler[OrganizationArtifactReport] with Unpickler[OrganizationArtifactReport] = PicklerUnpickler.generate[OrganizationArtifactReport] + def apply(organization: String, name: String, modules: Seq[ModuleReport]): OrganizationArtifactReport = new OrganizationArtifactReport(organization, name, modules) } @@ -188,6 +159,14 @@ object ModuleReport { def apply(module: ModuleID, artifacts: Seq[(Artifact, File)], missingArtifacts: Seq[Artifact]): ModuleReport = new ModuleReport(module, artifacts, missingArtifacts, None, None, None, None, false, None, None, None, None, Map(), None, None, Nil, Nil, Nil) + + import PairPicklers._ + import DatePicklers._ + private implicit val afPairPickler: Pickler[(Artifact, File)] with Unpickler[(Artifact, File)] = + pairPickler[Artifact, File] + private implicit def tuplePickler2: Pickler[(String, Option[String])] with Unpickler[(String, Option[String])] = + pairPickler[String, Option[String]] + implicit val pickler: Pickler[ModuleReport] with Unpickler[ModuleReport] = PicklerUnpickler.generate[ModuleReport] } final class Caller( @@ -201,6 +180,44 @@ final class Caller( override def toString: String = s"$caller" } +object Caller { + implicit val pickler: Pickler[Caller] with Unpickler[Caller] = PicklerUnpickler.generate[Caller] +} + +/** + * Provides information about dependency resolution. + * It does not include information about evicted modules, only about the modules ultimately selected by the conflict manager. + * This means that for a given configuration, there should only be one revision for a given organization and module name. + * @param cachedDescriptor the location of the resolved module descriptor in the cache + * @param configurations a sequence containing one report for each configuration resolved. + * @param stats information about the update that produced this report + * @see sbt.RichUpdateReport + */ +final class UpdateReport(val cachedDescriptor: File, val configurations: Seq[ConfigurationReport], val stats: UpdateStats, private[sbt] val stamps: Map[File, Long]) { + @deprecated("Use the variant that provides timestamps of files.", "0.13.0") + def this(cachedDescriptor: File, configurations: Seq[ConfigurationReport], stats: UpdateStats) = + this(cachedDescriptor, configurations, stats, Map.empty) + + override def toString = "Update report:\n\t" + stats + "\n" + configurations.mkString + + /** All resolved modules in all configurations. */ + def allModules: Seq[ModuleID] = configurations.flatMap(_.allModules).distinct + + def retrieve(f: (String, ModuleID, Artifact, File) => File): UpdateReport = + new UpdateReport(cachedDescriptor, configurations map { _ retrieve f }, stats, stamps) + + /** Gets the report for the given configuration, or `None` if the configuration was not resolved.*/ + def configuration(s: String) = configurations.find(_.configuration == s) + + /** Gets the names of all resolved configurations. This `UpdateReport` contains one `ConfigurationReport` for each configuration in this list. */ + def allConfigurations: Seq[String] = configurations.map(_.configuration) + + private[sbt] def withStats(us: UpdateStats): UpdateReport = + new UpdateReport(this.cachedDescriptor, + this.configurations, + us, + this.stamps) +} object UpdateReport { implicit def richUpdateReport(report: UpdateReport): RichUpdateReport = new RichUpdateReport(report) @@ -271,7 +288,61 @@ object UpdateReport { new UpdateReport(report.cachedDescriptor, newConfigurations, report.stats, report.stamps) } } + + import FileMapPicklers._ + private val vectorConfigurationReportPickler = implicitly[Pickler[Vector[ConfigurationReport]]] + private val vectorConfigurationReportUnpickler = implicitly[Unpickler[Vector[ConfigurationReport]]] + private val updateStatsPickler = implicitly[Pickler[UpdateStats]] + private val updateStatsUnpickler = implicitly[Unpickler[UpdateStats]] + private val flMapPickler = implicitly[Pickler[Map[File, Long]]] + private val flMapUnpickler = implicitly[Unpickler[Map[File, Long]]] + + implicit val pickler: Pickler[UpdateReport] with Unpickler[UpdateReport] = new Pickler[UpdateReport] with Unpickler[UpdateReport] { + val tag = implicitly[FastTypeTag[UpdateReport]] + val fileTag = implicitly[FastTypeTag[File]] + val vectorConfigurationReportTag = implicitly[FastTypeTag[Vector[ConfigurationReport]]] + val updateStatsTag = implicitly[FastTypeTag[UpdateStats]] + val flMapTag = implicitly[FastTypeTag[Map[File, Long]]] + def pickle(a: UpdateReport, builder: PBuilder): Unit = { + builder.pushHints() + builder.hintTag(tag) + builder.beginEntry(a) + builder.putField("cachedDescriptor", { b => + b.hintTag(fileTag) + filePickler.pickle(a.cachedDescriptor, b) + }) + builder.putField("configurations", { b => + b.hintTag(vectorConfigurationReportTag) + vectorConfigurationReportPickler.pickle(a.configurations.toVector, b) + }) + builder.putField("stats", { b => + b.hintTag(updateStatsTag) + updateStatsPickler.pickle(a.stats, b) + }) + builder.putField("stamps", { b => + b.hintTag(flMapTag) + flMapPickler.pickle(a.stamps, b) + }) + builder.endEntry() + builder.popHints() + } + + def unpickle(tpe: String, reader: PReader): Any = { + reader.pushHints() + reader.hintTag(tag) + reader.beginEntry() + val cachedDescriptor = filePickler.unpickleEntry(reader.readField("cachedDescriptor")).asInstanceOf[File] + val configurations = vectorConfigurationReportUnpickler.unpickleEntry(reader.readField("configurations")).asInstanceOf[Vector[ConfigurationReport]] + val stats = updateStatsUnpickler.unpickleEntry(reader.readField("stats")).asInstanceOf[UpdateStats] + val stamps = flMapUnpickler.unpickleEntry(reader.readField("stamps")).asInstanceOf[Map[File, Long]] + val result = new UpdateReport(cachedDescriptor, configurations, stats, stamps) + reader.endEntry() + reader.popHints() + result + } + } } + final class UpdateStats(val resolveTime: Long, val downloadTime: Long, val downloadSize: Long, val cached: Boolean) { override def toString = Seq("Resolve time: " + resolveTime + " ms", "Download time: " + downloadTime + " ms", "Download size: " + downloadSize + " bytes").mkString(", ") private[sbt] def withCached(c: Boolean): UpdateStats = @@ -279,4 +350,7 @@ final class UpdateStats(val resolveTime: Long, val downloadTime: Long, val downl downloadTime = this.downloadTime, downloadSize = this.downloadSize, cached = c) -} \ No newline at end of file +} +object UpdateStats { + implicit val pickler: Pickler[UpdateStats] with Unpickler[UpdateStats] = PicklerUnpickler.generate[UpdateStats] +} diff --git a/ivy/src/test/scala/DMSerializationSpec.scala b/ivy/src/test/scala/DMSerializationSpec.scala new file mode 100644 index 000000000..bf62de10b --- /dev/null +++ b/ivy/src/test/scala/DMSerializationSpec.scala @@ -0,0 +1,67 @@ +package sbt + +import org.specs2._ +import matcher.MatchResult +import java.net.URL +import java.io.File +import sbt.serialization._ + +class DMSerializationSpec extends Specification { + def is = sequential ^ s2""" + + This is a specification to check the serialization of dependency graph. + + CrossVersion.full should + ${roundtripStr(CrossVersion.full: sbt.CrossVersion)} + CrossVersion.binary should + ${roundtripStr(CrossVersion.binary: sbt.CrossVersion)} + CrossVersion.Disabled should + ${roundtrip(CrossVersion.Disabled: sbt.CrossVersion)} + + Artifact("foo") should + ${roundtrip(Artifact("foo"))} + Artifact("foo", "sources") should + ${roundtrip(Artifact("foo", "sources"))} + Artifact.pom("foo") should + ${roundtrip(Artifact.pom("foo"))} + Artifact("foo", url("http://example.com/")) should + ${roundtrip(Artifact("foo", new URL("http://example.com/")))} + Artifact("foo").extra(("key", "value")) should + ${roundtrip(Artifact("foo").extra(("key", "value")))} + + ModuleID("org", "name", "1.0") should + ${roundtrip(ModuleID("org", "name", "1.0"))} + + ModuleReport(ModuleID("org", "name", "1.0"), Nil, Nil) should + ${roundtripStr(ModuleReport(ModuleID("org", "name", "1.0"), Nil, Nil))} + Organization artifact report should + ${roundtripStr(organizationArtifactReportExample)} + Configuration report should + ${roundtripStr(configurationReportExample)} + Update report should + ${roundtripStr(updateReportExample)} + """ + + lazy val updateReportExample = + new UpdateReport(new File("./foo"), Vector(configurationReportExample), + new UpdateStats(0, 0, 0, false), Map(new File("./foo") -> 0)) + lazy val configurationReportExample = + new ConfigurationReport("compile", Vector(moduleReportExample), + Vector(organizationArtifactReportExample), Nil) + lazy val organizationArtifactReportExample = + new OrganizationArtifactReport("org", "name", Vector(moduleReportExample)) + lazy val moduleReportExample = + ModuleReport(ModuleID("org", "name", "1.0"), Nil, Nil) + + def roundtrip[A: Pickler: Unpickler](a: A) = + roundtripBuilder(a) { _ must_== _ } + def roundtripStr[A: Pickler: Unpickler](a: A) = + roundtripBuilder(a) { _.toString must_== _.toString } + def roundtripBuilder[A: Pickler: Unpickler](a: A)(f: (A, A) => MatchResult[Any]): MatchResult[Any] = + { + val json = toJsonString(a) + println(json) + val obj = fromJsonString[A](json).get + f(a, obj) + } +} diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 5be547f47..b28fa4c00 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -12,9 +12,7 @@ object Dependencies { lazy val ivy = "org.scala-sbt.ivy" % "ivy" % "2.3.0-sbt-fccfbd44c9f64523b61398a0155784dcbaeae28f" lazy val jsch = "com.jcraft" % "jsch" % "0.1.46" intransitive () lazy val sbinary = "org.scala-tools.sbinary" %% "sbinary" % "0.4.2" - lazy val json4sNative = "org.json4s" %% "json4s-native" % "3.2.10" - lazy val jawnParser = "org.spire-math" %% "jawn-parser" % "0.6.0" - lazy val jawnJson4s = "org.spire-math" %% "json4s-support" % "0.6.0" + lazy val sbtSerialization = "org.scala-sbt" %% "serialization" % "0.1.0" lazy val scalaCompiler = Def.setting { "org.scala-lang" % "scala-compiler" % scalaVersion.value } lazy val testInterface = "org.scala-sbt" % "test-interface" % "1.0" lazy val scalaCheck = "org.scalacheck" %% "scalacheck" % "1.11.4"