From 958310a105a1a7eb38fbc4b81671cebd8c9f00a3 Mon Sep 17 00:00:00 2001 From: dmharrah Date: Fri, 25 Sep 2009 13:11:14 +0000 Subject: [PATCH] Inline Ivy module configurations git-svn-id: https://simple-build-tool.googlecode.com/svn/trunk@1047 d89573ee-9141-11dd-94d4-bdf5e562f29c --- ivysettings.xml | 1 + src/main/scala/sbt/BasicProjectTypes.scala | 13 ++++++++++++- src/main/scala/sbt/ManageDependencies.scala | 19 +++++++++++++++++-- src/main/scala/sbt/ManagedInterface.scala | 13 ++++++++++--- 4 files changed, 40 insertions(+), 6 deletions(-) diff --git a/ivysettings.xml b/ivysettings.xml index 2cb9d1630..780f2b928 100644 --- a/ivysettings.xml +++ b/ivysettings.xml @@ -1,3 +1,4 @@ + diff --git a/src/main/scala/sbt/BasicProjectTypes.scala b/src/main/scala/sbt/BasicProjectTypes.scala index 969f84b77..5c2817380 100644 --- a/src/main/scala/sbt/BasicProjectTypes.scala +++ b/src/main/scala/sbt/BasicProjectTypes.scala @@ -232,7 +232,7 @@ trait BasicManagedProject extends ManagedProject with ReflectiveManagedProject w /** The dependency manager that represents inline declarations. The default manager packages the information * from 'ivyXML', 'projectID', 'repositories', and 'libraryDependencies' and does not typically need to be * be overridden. */ - def manager = new SimpleManager(ivyXML, true, projectID, repositories.toSeq, ivyConfigurations, defaultConfiguration, libraryDependencies.toList: _*) + def manager = new SimpleManager(ivyXML, true, projectID, repositories.toSeq, moduleConfigurations.toSeq, ivyConfigurations, defaultConfiguration, libraryDependencies.toList: _*) /** The pattern for Ivy to use when retrieving dependencies into the local project. Classpath management * depends on the first directory being [conf] and the extension being [ext].*/ @@ -607,6 +607,17 @@ trait ReflectiveRepositories extends Project } } def reflectiveRepositories: Map[String, Resolver] = Reflective.reflectiveMappings[Resolver](this) + + def moduleConfigurations: Set[ModuleConfiguration] = + { + val reflective = Set[ModuleConfiguration](reflectiveModuleConfigurations.values.toList: _*) + info.parent match + { + case Some(p: ReflectiveRepositories) => p.moduleConfigurations ++ reflective + case None => reflective + } + } + def reflectiveModuleConfigurations: Map[String, ModuleConfiguration] = Reflective.reflectiveMappings[ModuleConfiguration](this) } trait ReflectiveManagedProject extends ReflectiveProject with ReflectiveArtifacts with ReflectiveRepositories with ReflectiveLibraryDependencies with ReflectiveConfigurations \ No newline at end of file diff --git a/src/main/scala/sbt/ManageDependencies.scala b/src/main/scala/sbt/ManageDependencies.scala index 8eb95dc79..16d6f2920 100644 --- a/src/main/scala/sbt/ManageDependencies.scala +++ b/src/main/scala/sbt/ManageDependencies.scala @@ -11,7 +11,7 @@ import scala.collection.mutable.HashSet import Artifact.{defaultExtension, defaultType} import org.apache.ivy.{core, plugins, util, Ivy} -import core.LogOptions +import core.{IvyPatternHelper, LogOptions} import core.cache.DefaultRepositoryCacheManager import core.deliver.DeliverOptions import core.install.InstallOptions @@ -200,12 +200,13 @@ object ManageDependencies case sm: SbtManager => { import sm._ - if(resolvers.isEmpty && autodetectUnspecified) + if(resolvers.isEmpty && moduleConfigurations.isEmpty && autodetectUnspecified) autodetectConfiguration() else { log.debug("Using inline repositories.") configureDefaults(withDefaultResolvers(resolvers)) + setModuleConfigurations(settings, moduleConfigurations) } if(autodetect) autodetectDependencies(toID(module), true) @@ -563,6 +564,20 @@ object ManageDependencies moduleID.setModuleArtifact(artifact) moduleID.check() } + private def setModuleConfigurations(settings: IvySettings, moduleConfigurations: Seq[ModuleConfiguration]) + { + val existing = settings.getResolverNames + for(moduleConf <- moduleConfigurations) + { + import moduleConf._ + import IvyPatternHelper._ + import PatternMatcher._ + if(!existing.contains(resolver.name)) + settings.addResolver(ConvertResolver(resolver)) + val attributes = javaMap(Map(MODULE_KEY -> name, ORGANISATION_KEY -> organization, REVISION_KEY -> revision)) + settings.addModuleConfiguration(attributes, settings.getMatcher(EXACT_OR_REGEXP), resolver.name, null, null, null) + } + } /** Sets the resolvers for 'settings' to 'resolvers'. This is done by creating a new chain and making it the default. */ private def setResolvers(settings: IvySettings, resolvers: Seq[Resolver], log: Logger) { diff --git a/src/main/scala/sbt/ManagedInterface.scala b/src/main/scala/sbt/ManagedInterface.scala index 83a4376ea..9233c0029 100644 --- a/src/main/scala/sbt/ManagedInterface.scala +++ b/src/main/scala/sbt/ManagedInterface.scala @@ -29,6 +29,7 @@ sealed trait SbtManager extends Manager def autodetect: Boolean def module: ModuleID def resolvers: Seq[Resolver] + def moduleConfigurations: Seq[ModuleConfiguration] def dependencies: Iterable[ModuleID] def autodetectUnspecified: Boolean def dependenciesXML: NodeSeq @@ -36,8 +37,9 @@ sealed trait SbtManager extends Manager def defaultConfiguration: Option[Configuration] } final class SimpleManager private[sbt] (val dependenciesXML: NodeSeq, val autodetectUnspecified: Boolean, - val module: ModuleID, val resolvers: Seq[Resolver], explicitConfigurations: Iterable[Configuration], - val defaultConfiguration: Option[Configuration], val dependencies: ModuleID*) extends SbtManager + val module: ModuleID, val resolvers: Seq[Resolver], val moduleConfigurations: Seq[ModuleConfiguration], + explicitConfigurations: Iterable[Configuration], val defaultConfiguration: Option[Configuration], + val dependencies: ModuleID*) extends SbtManager { def autodetect = dependencies.isEmpty && dependenciesXML.isEmpty && module.explicitArtifacts.isEmpty && explicitConfigurations.isEmpty && autodetectUnspecified def configurations = @@ -53,7 +55,12 @@ final class SimpleManager private[sbt] (val dependenciesXML: NodeSeq, val autode else explicitConfigurations } - +final case class ModuleConfiguration(organization: String, name: String, revision: String, resolver: Resolver) extends NotNull +object ModuleConfiguration +{ + def apply(org: String, resolver: Resolver): ModuleConfiguration = apply(org, "*", "*", resolver) + def apply(org: String, name: String, resolver: Resolver): ModuleConfiguration = ModuleConfiguration(org, name, "*", resolver) +} final case class ModuleID(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, explicitArtifacts: Seq[Artifact], extraAttributes: Map[String,String]) extends NotNull { override def toString = organization + ":" + name + ":" + revision