From a6ef6481ac3d1a232b9ab8e2de4afeaac4a477ae Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Sun, 31 Jul 2011 22:17:50 -0400 Subject: [PATCH] use configurations for modules for update-classifiers. fixes #104 --- ivy/IvyActions.scala | 15 +++++++++------ ivy/UpdateReport.scala | 5 +++-- main/Defaults.scala | 20 +++++++++++++------- main/Keys.scala | 1 + 4 files changed, 26 insertions(+), 15 deletions(-) diff --git a/ivy/IvyActions.scala b/ivy/IvyActions.scala index 387fdd60b..45944d5a1 100644 --- a/ivy/IvyActions.scala +++ b/ivy/IvyActions.scala @@ -28,7 +28,8 @@ final class UpdateConfiguration(val retrieve: Option[RetrieveConfiguration], val final class RetrieveConfiguration(val retrieveDirectory: File, val outputPattern: String) final case class MakePomConfiguration(file: File, configurations: Option[Iterable[Configuration]] = None, extra: NodeSeq = NodeSeq.Empty, process: XNode => XNode = n => n, filterRepositories: MavenRepository => Boolean = _ => true, allRepositories: Boolean) // exclude is a map on a restricted ModuleID -final case class GetClassifiersConfiguration(id: ModuleID, modules: Seq[ModuleID], classifiers: Seq[String], exclude: Map[ModuleID, Set[String]], configuration: UpdateConfiguration, ivyScala: Option[IvyScala]) +final case class GetClassifiersConfiguration(module: GetClassifiersModule, exclude: Map[ModuleID, Set[String]], configuration: UpdateConfiguration, ivyScala: Option[IvyScala]) +final case class GetClassifiersModule(id: ModuleID, modules: Seq[ModuleID], configurations: Seq[Configuration], classifiers: Seq[String]) /** Configures logging during an 'update'. `level` determines the amount of other information logged. * `Full` is the default and logs the most. @@ -166,21 +167,23 @@ object IvyActions def transitiveScratch(ivySbt: IvySbt, label: String, config: GetClassifiersConfiguration, log: Logger): UpdateReport = { - import config.{configuration => c, id, ivyScala, modules => deps} + import config.{configuration => c, ivyScala, module => mod} + import mod.{configurations => confs, id, modules => deps} val base = restrictedCopy(id).copy(name = id.name + "$" + label) val module = new ivySbt.Module(InlineConfiguration(base, deps).copy(ivyScala = ivyScala)) val report = update(module, c, log) - val newConfig = config.copy(modules = report.allModules) + val newConfig = config.copy(module = mod.copy(modules = report.allModules)) updateClassifiers(ivySbt, newConfig, log) } def updateClassifiers(ivySbt: IvySbt, config: GetClassifiersConfiguration, log: Logger): UpdateReport = { - import config.{configuration => c, _} + import config.{configuration => c, module => mod, _} + import mod.{configurations => confs, _} assert(!classifiers.isEmpty, "classifiers cannot be empty") val baseModules = modules map restrictedCopy val deps = baseModules.distinct flatMap classifiedArtifacts(classifiers, exclude) val base = restrictedCopy(id).copy(name = id.name + classifiers.mkString("$","_","")) - val module = new ivySbt.Module(InlineConfiguration(base, deps).copy(ivyScala = ivyScala)) + val module = new ivySbt.Module(InlineConfiguration(base, deps).copy(ivyScala = ivyScala, configurations = confs)) val upConf = new UpdateConfiguration(c.retrieve, true, c.logging) update(module, upConf, log) } @@ -198,7 +201,7 @@ object IvyActions def extractExcludes(report: UpdateReport): Map[ModuleID, Set[String]] = report.allMissing flatMap { case (_, mod, art) => art.classifier.map { c => (restrictedCopy(mod), c) } } groupBy(_._1) map { case (mod, pairs) => (mod, pairs.map(_._2).toSet) } - private[this] def restrictedCopy(m: ModuleID) = ModuleID(m.organization, m.name, m.revision, crossVersion = m.crossVersion, extraAttributes = m.extraAttributes) + private[this] def restrictedCopy(m: ModuleID) = ModuleID(m.organization, m.name, m.revision, crossVersion = m.crossVersion, extraAttributes = m.extraAttributes, configurations = m.configurations) private[this] def resolve(logging: UpdateLogging.Value)(ivy: Ivy, module: DefaultModuleDescriptor, defaultConf: String): (ResolveReport, Option[ResolveException]) = { val resolveOptions = new ResolveOptions diff --git a/ivy/UpdateReport.scala b/ivy/UpdateReport.scala index 28145f7e5..241ecded5 100644 --- a/ivy/UpdateReport.scala +++ b/ivy/UpdateReport.scala @@ -40,8 +40,9 @@ final class ConfigurationReport(val configuration: String, val modules: Seq[Modu /** All resolved modules for this configuration. * For a given organization and module name, there is only one revision/`ModuleID` in this sequence. */ - def allModules: Seq[ModuleID] = modules.map(_.module) - + def allModules: Seq[ModuleID] = modules.map(mr => addConfiguration(mr.module)) + private[this] def addConfiguration(mod: ModuleID): ModuleID = if(mod.configurations.isEmpty) mod.copy(configurations = Some(configuration)) else mod + def retrieve(f: (String, ModuleID, Artifact, File) => File): ConfigurationReport = new ConfigurationReport(configuration, modules map { _.retrieve( (mid,art,file) => f(configuration, mid, art, file)) }, evicted) } diff --git a/main/Defaults.scala b/main/Defaults.scala index 4aedc7115..51972a950 100644 --- a/main/Defaults.scala +++ b/main/Defaults.scala @@ -663,9 +663,12 @@ object Classpaths }, update <<= (conflictWarning, update, streams) map { (config, report, s) => ConflictWarning(config, report, s.log); report }, transitiveClassifiers in GlobalScope :== Seq(SourceClassifier, DocClassifier), - updateClassifiers <<= (ivySbt, projectID, update, transitiveClassifiers in updateClassifiers, updateConfiguration, ivyScala, target in LocalRootProject, appConfiguration, streams) map { (is, pid, up, classifiers, c, ivyScala, out, app, s) => - withExcludes(out, classifiers, lock(app)) { excludes => - IvyActions.updateClassifiers(is, GetClassifiersConfiguration(pid, up.allModules, classifiers, excludes, c, ivyScala), s.log) + classifiersModule in updateClassifiers <<= (projectID, update, transitiveClassifiers in updateClassifiers, ivyConfigurations in updateClassifiers) map { ( pid, up, classifiers, confs) => + GetClassifiersModule(pid, up.allModules, confs, classifiers) + }, + updateClassifiers <<= (ivySbt, classifiersModule in updateClassifiers, updateConfiguration, ivyScala, target in LocalRootProject, appConfiguration, streams) map { (is, mod, c, ivyScala, out, app, s) => + withExcludes(out, mod.classifiers, lock(app)) { excludes => + IvyActions.updateClassifiers(is, GetClassifiersConfiguration(mod, excludes, c, ivyScala), s.log) } }, sbtDependency in GlobalScope <<= appConfiguration { app => @@ -696,10 +699,13 @@ object Classpaths new InlineIvyConfiguration(paths, rs, Nil, Nil, off, Option(lock(app)), check, s.log) }, ivySbt <<= ivySbt0, - updateSbtClassifiers in TaskGlobal <<= (ivySbt, projectID, transitiveClassifiers, updateConfiguration, sbtDependency, ivyScala, target in LocalRootProject, appConfiguration, streams) map { - (is, pid, classifiers, c, sbtDep, ivyScala, out, app, s) => - withExcludes(out, classifiers, lock(app)) { excludes => - IvyActions.transitiveScratch(is, "sbt", GetClassifiersConfiguration(pid, sbtDep :: Nil, classifiers, excludes, c, ivyScala), s.log) + classifiersModule <<= (projectID, sbtDependency, transitiveClassifiers) map { ( pid, sbtDep, classifiers) => + GetClassifiersModule(pid, sbtDep :: Nil, Configurations.Default :: Nil, classifiers) + }, + updateSbtClassifiers in TaskGlobal <<= (ivySbt, classifiersModule, updateConfiguration, ivyScala, target in LocalRootProject, appConfiguration, streams) map { + (is, mod, c, ivyScala, out, app, s) => + withExcludes(out, mod.classifiers, lock(app)) { excludes => + IvyActions.transitiveScratch(is, "sbt", GetClassifiersConfiguration(mod, excludes, c, ivyScala), s.log) } } )) diff --git a/main/Keys.scala b/main/Keys.scala index 6316c13ad..2b4b8430d 100644 --- a/main/Keys.scala +++ b/main/Keys.scala @@ -256,6 +256,7 @@ object Keys val packagedArtifact = TaskKey[(Artifact, File)]("packaged-artifact", "Generates a packaged artifact, returning the Artifact and the produced File.") val checksums = SettingKey[Seq[String]]("checksums", "The list of checksums to generate and to verify for dependencies.") + val classifiersModule = TaskKey[GetClassifiersModule]("classifiers-module") val conflictWarning = SettingKey[ConflictWarning]("conflict-warning", "Configures warnings for conflicts in dependency management.") val autoScalaLibrary = SettingKey[Boolean]("auto-scala-library", "Adds a dependency on scala-library if true.") val sbtResolver = SettingKey[Resolver]("sbt-resolver", "Provides a resolver for obtaining sbt as a dependency.")