package sbt
trait trait ClasspathProject extends java.lang.Object with sbt.Project with ScalaObjectClasspathProject extends sbt.ProjectProject
{
def (sbt.Configuration)sbt.PathFinderprojectClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration): sbt.PathFinderPathFinder
def (sbt.Configuration)sbt.PathFinderfullClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration): sbt.PathFinderPathFinder =
object sbt.PathPath.(=> Iterable[sbt.Path])sbt.PathFinderlazyPathFinder
{
val scala.collection.jcl.LinkedHashSet[sbt.Path]set = ()scala.collection.jcl.LinkedHashSet[sbt.Path]new scala.collection.jcl.scala.collection.jcl.LinkedHashSet[sbt.Path]LinkedHashSet[Path]
for(((sbt.Project) => Unit)Unitproject <- => List[sbt.Project]topologicalSort)
{
sbt.Projectproject Unitmatch
{
Unitcase sbt.ClasspathProjectsp: sbt.ClasspathProjectClasspathProject => scala.collection.jcl.LinkedHashSet[sbt.Path]set (Iterable[sbt.Path])Unit++= sbt.ClasspathProjectsp.(sbt.Configuration)sbt.PathFinderprojectClasspath(sbt.Configurationconfig).=> scala.collection.Set[sbt.Path]get
Unitcase _ => Unit()
}
}
scala.collection.jcl.LinkedHashSet[sbt.Path]set.=> List[sbt.Path]toList
}
}
trait trait BasicDependencyProject extends java.lang.Object with sbt.BasicManagedProject with sbt.UnmanagedClasspathProject with ScalaObjectBasicDependencyProject extends sbt.BasicManagedProjectBasicManagedProject with sbt.UnmanagedClasspathProjectUnmanagedClasspathProject
{
def (sbt.Configuration)sbt.PathFinderprojectClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration) = (sbt.Configuration)sbt.PathFinderfullUnmanagedClasspath(sbt.Configurationconfig) (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration)sbt.PathFindermanagedClasspath(sbt.Configurationconfig)
}
trait trait UnmanagedClasspathProject extends java.lang.Object with sbt.ClasspathProject with ScalaObjectUnmanagedClasspathProject extends sbt.ClasspathProjectClasspathProject
{
def => sbt.PathdependencyPath: sbt.PathPath
def => sbt.PathFinderunmanagedClasspath: sbt.PathFinderPathFinder = (sbt.PathFinder,sbt.FileFilter)sbt.PathFinderdescendents(=> sbt.PathdependencyPath, implicit sbt.Project.filter : (String)sbt.NameFilter"*.jar")
def (sbt.Configuration)sbt.PathFinderfullUnmanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration): sbt.PathFinderPathFinder
}
trait trait ManagedProject extends java.lang.Object with sbt.ClasspathProject with ScalaObjectManagedProject extends sbt.ClasspathProjectClasspathProject
{
trait trait ManagedOption extends java.lang.Object with ManagedProject.this.ActionOptionManagedOption extends ManagedProject.this.ActionOptionActionOption
final class class ManagedFlagOption extends java.lang.Object with ManagedProject.this.ManagedOption with ScalaObjectManagedFlagOption extends ManagedProject.this.ManagedOptionManagedOption
final val ManagedProject.this.ManagedFlagOptionSynchronize = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
final val ManagedProject.this.ManagedFlagOptionValidate = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
final val ManagedProject.this.ManagedFlagOptionQuietUpdate = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
final val ManagedProject.this.ManagedFlagOptionAddScalaToolsReleases = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
final val ManagedProject.this.ManagedFlagOptionErrorIfNoConfiguration = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
final case class class LibraryManager extends java.lang.Object with ManagedProject.this.ManagedOption with ScalaObject with ProductLibraryManager(sbt.Managerm: sbt.ManagerManager) extends ManagedProject.this.ManagedOptionManagedOption
final case class class CacheDirectory extends java.lang.Object with ManagedProject.this.ManagedOption with ScalaObject with ProductCacheDirectory(sbt.Pathdir: sbt.PathPath) extends ManagedProject.this.ManagedOptionManagedOption
final case class class CheckScalaVersion extends java.lang.Object with ManagedProject.this.ManagedOption with ScalaObject with ProductCheckScalaVersion(Iterable[sbt.Configuration]configs: Iterable[sbt.Configuration]Iterable[Configuration], BooleancheckExplicit: BooleanBoolean, BooleanfilterImplicit: BooleanBoolean) extends ManagedProject.this.ManagedOptionManagedOption
private def (String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(StringoutputPattern: StringString, sbt.PathmanagedDependencyPath: sbt.PathPath, Seq[ManagedProject.this.ManagedOption]options: Seq[ManagedProject.this.ManagedOption]Seq[ManagedOption])
((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String]doWith: (IvyConfiguration, UpdateConfiguration) => Option[String]) =
{
var Booleansynchronize = Boolean(false)false
var Booleanvalidate = Boolean(false)false
var Booleanquiet = Boolean(false)false
var BooleanaddScalaTools = Boolean(false)false
var BooleanerrorIfNoConfiguration = Boolean(false)false
var sbt.Managermanager: sbt.ManagerManager = sbt.AutoDetectManagernew sbt.AutoDetectManagerAutoDetectManager(=> sbt.ModuleIDprojectID)
var Option[sbt.Path]cacheDirectory: Option[sbt.Path]Option[Path] = object NoneNone
var Option[sbt.IvyScala]checkScalaVersion: Option[sbt.IvyScala]Option[IvyScala] = object NoneNone
for(((ManagedProject.this.ManagedOption) => Unit)Unitoption <- Seq[ManagedProject.this.ManagedOption]options)
{
ManagedProject.this.ManagedOptionoption Unitmatch
{
Unitcase => ManagedProject.this.ManagedFlagOptionSynchronize => Booleansynchronize = Boolean(true)true
Unitcase => ManagedProject.this.ManagedFlagOptionValidate => Booleanvalidate = Boolean(true)true
Unitcase LibraryManager(sbt.Managerm) => sbt.Managermanager = sbt.Managerm
Unitcase => ManagedProject.this.ManagedFlagOptionQuietUpdate => Booleanquiet = Boolean(true)true
Unitcase => ManagedProject.this.ManagedFlagOptionAddScalaToolsReleases => BooleanaddScalaTools = Boolean(true)true
Unitcase => ManagedProject.this.ManagedFlagOptionErrorIfNoConfiguration => BooleanerrorIfNoConfiguration = Boolean(true)true
Unitcase CacheDirectory(sbt.Pathdir) => Option[sbt.Path]cacheDirectory = (sbt.Path)Some[sbt.Path]Some(sbt.Pathdir)
Unitcase CheckScalaVersion(Iterable[sbt.Configuration]configs, BooleancheckExplicit, BooleanfilterImplicit) =>
Option[sbt.IvyScala]checkScalaVersion = => Option[String]getScalaVersion.((String) => sbt.IvyScala)Option[sbt.IvyScala]map(Stringversion => sbt.IvyScalanew sbt.IvyScalaIvyScala(Stringversion, Iterable[sbt.Configuration]configs, BooleancheckExplicit, BooleanfilterImplicit))
Unitcase _ => => sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("Ignored unknown managed option ")"Ignored unknown managed option " (Any)java.lang.String+ ManagedProject.this.ManagedOptionoption)
}
}
val sbt.IvyPathsivyPaths = sbt.IvyPathsnew sbt.IvyPathsIvyPaths(=> sbt.ProjectInfoinfo.=> sbt.ProjectDirectoryprojectPath, sbt.PathmanagedDependencyPath, Option[sbt.Path]cacheDirectory)
val sbt.IvyFlagsivyFlags = sbt.IvyFlagsnew sbt.IvyFlagsIvyFlags(Booleanvalidate, BooleanaddScalaTools, BooleanerrorIfNoConfiguration)
val sbt.IvyConfigurationivyConfiguration = sbt.IvyConfigurationnew sbt.IvyConfigurationIvyConfiguration(sbt.IvyPathsivyPaths, sbt.Managermanager, sbt.IvyFlagsivyFlags, Option[sbt.IvyScala]checkScalaVersion, => sbt.Loggerlog)
val sbt.UpdateConfigurationupdateConfiguration = sbt.UpdateConfigurationnew sbt.UpdateConfigurationUpdateConfiguration(StringoutputPattern, Booleansynchronize, Booleanquiet)
(sbt.IvyConfiguration,sbt.UpdateConfiguration)Option[String]doWith(sbt.IvyConfigurationivyConfiguration, sbt.UpdateConfigurationupdateConfiguration)
}
private def => Option[String]getScalaVersion =
{
val Stringv = => ManagedProject.this.Property[String]scalaVersion.=> Stringvalue
Option[String]if(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringv.=> BooleanisEmpty) object NoneNone
else (String)Some[String]Some(Stringv)
}
private def (=> Option[String])ManagedProject.this.TaskwithIvyTask(=> Option[String]doTask: => Option[String]) =
(=> Option[String])ManagedProject.this.Tasktask
{
try { => Option[String]doTask }
catch
{
Some[java.lang.String]case java.lang.NoClassDefFoundErrore: java.lang.NoClassDefFoundErrorNoClassDefFoundError =>
=> sbt.Loggerlog.(=> Throwable)Unittrace(java.lang.NoClassDefFoundErrore)
(java.lang.String)Some[java.lang.String]Some(java.lang.String("Apache Ivy is required for dependency management (")"Apache Ivy is required for dependency management (" (Any)java.lang.String+ java.lang.NoClassDefFoundErrore.()java.lang.StringtoString (Any)java.lang.String+ java.lang.String(")")")")
}
}
def (String,sbt.Path,ManagedProject.this.ManagedOption*)ManagedProject.this.TaskupdateTask(StringoutputPattern: StringString, sbt.PathmanagedDependencyPath: sbt.PathPath, ManagedProject.this.ManagedOption*options: ManagedProject.this.ManagedOption*ManagedOption*): ManagedProject.this.TaskTask =
(String,sbt.Path,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskupdateTask(StringoutputPattern, sbt.PathmanagedDependencyPath, ManagedProject.this.ManagedOption*options)
def (String,sbt.Path,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskupdateTask(StringoutputPattern: StringString, sbt.PathmanagedDependencyPath: sbt.PathPath, => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(StringoutputPattern, sbt.PathmanagedDependencyPath, => Seq[ManagedProject.this.ManagedOption]options)(object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration,sbt.UpdateConfiguration)Option[String]update))
def (sbt.PublishConfiguration,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskpublishTask(sbt.PublishConfigurationpublishConfig: sbt.PublishConfigurationPublishConfiguration, => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
{
import publishConfig._
(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(java.lang.String("")"", => sbt.PathmanagedDependencyPath, => Seq[ManagedProject.this.ManagedOption]options) { (sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationignore) =>
object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration,String,Iterable[String],String,Option[Iterable[sbt.Configuration]])Option[String]publish(sbt.IvyConfigurationivyConf, => StringresolverName, => Iterable[String]srcArtifactPatterns, => StringdeliveredPattern, => Option[Iterable[sbt.Configuration]]configurations) } )
}
def (sbt.PublishConfiguration,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskdeliverTask(sbt.PublishConfigurationdeliverConfig: sbt.PublishConfigurationPublishConfiguration, => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
{
import deliverConfig._
(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(java.lang.String("")"", => sbt.PathmanagedDependencyPath, => Seq[ManagedProject.this.ManagedOption]options) { (sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationupdateConf) =>
object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration,sbt.UpdateConfiguration,String,String,Iterable[sbt.ModuleID],Option[Iterable[sbt.Configuration]])Option[String]deliver(sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationupdateConf, => Stringstatus, => StringdeliveredPattern, => Iterable[sbt.ModuleID]extraDependencies, => Option[Iterable[sbt.Configuration]]configurations) } )
}
def (sbt.Path,Iterable[sbt.ModuleID],=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskmakePomTask(sbt.Pathoutput: sbt.PathPath, Iterable[sbt.ModuleID]extraDependencies: Iterable[sbt.ModuleID]Iterable[ModuleID], => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(java.lang.String("")"", => sbt.PathmanagedDependencyPath: sbt.PathPath, => Seq[ManagedProject.this.ManagedOption]options) { (sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationignore) =>
object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration,Iterable[sbt.ModuleID],java.io.File)Option[String]makePom(sbt.IvyConfigurationivyConf, Iterable[sbt.ModuleID]extraDependencies, sbt.Pathoutput.=> java.io.FileasFile) })
def (sbt.Path,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskcleanCacheTask(sbt.PathmanagedDependencyPath: sbt.PathPath, => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(java.lang.String("")"", sbt.PathmanagedDependencyPath, => Seq[ManagedProject.this.ManagedOption]options) { (sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationignore) => object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration)Option[String]cleanCache(sbt.IvyConfigurationivyConf) })
def (sbt.Path)ManagedProject.this.TaskcleanLibTask(sbt.PathmanagedDependencyPath: sbt.PathPath) = (=> Option[String])ManagedProject.this.Tasktask { object sbt.FileUtilitiesFileUtilities.(Iterable[sbt.Path],sbt.Logger)Option[String]clean(sbt.PathmanagedDependencyPath.=> scala.collection.Set[sbt.Path]get, => sbt.Loggerlog) }
def => sbt.ModuleIDprojectID: sbt.ModuleIDModuleID = (String,String,String,Option[String])sbt.ModuleIDModuleID(=> Stringorganization, => java.lang.StringnormalizedName, => sbt.Versionversion.()java.lang.StringtoString, object NoneNone)
def => sbt.PathmanagedDependencyPath: sbt.PathPath
final def (sbt.Configuration)sbt.PathFindermanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration): sbt.PathFinderPathFinder = (sbt.Configuration,Boolean)sbt.PathFindermanagedClasspath(sbt.Configurationconfig, Boolean(true)true)
def (sbt.Configuration,Boolean)sbt.PathFindermanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration, BooleanuseDefaultFallback: BooleanBoolean): sbt.PathFinderPathFinder =
{
val sbt.PathconfigDirectory = => sbt.PathmanagedDependencyPath (String)sbt.Path/ sbt.Configurationconfig.()StringtoString
val sbt.PathFinderuseDirectory =
sbt.PathFinderif(sbt.PathconfigDirectory.=> java.io.FileasFile.()Booleanexists)
sbt.PathconfigDirectory
else sbt.PathFinderif(BooleanuseDefaultFallback)
=> sbt.PathmanagedDependencyPath (String)sbt.Path/ object sbt.ConfigurationsConfigurations.=> sbt.ConfigurationDefault.()StringtoString
else
object sbt.PathPath.=> sbt.PathFinderemptyPathFinder
(sbt.PathFinder,sbt.FileFilter)sbt.PathFinderdescendents(sbt.PathFinderuseDirectory, implicit sbt.Project.filter : (String)sbt.NameFilter"*.jar")
}
import StringUtilities.nonEmpty
implicit def implicit sbt.ManagedProject.toGroupID : (String)sbt.GroupIDtoGroupID(StringgroupID: StringString): sbt.GroupIDGroupID =
{
(String,String)UnitnonEmpty(StringgroupID, java.lang.String("Group ID")"Group ID")
sbt.GroupIDnew sbt.GroupIDGroupID(StringgroupID)
}
implicit def implicit sbt.ManagedProject.toRepositoryName : (String)sbt.RepositoryNametoRepositoryName(Stringname: StringString): sbt.RepositoryNameRepositoryName =
{
(String,String)UnitnonEmpty(Stringname, java.lang.String("Repository name")"Repository name")
sbt.RepositoryNamenew sbt.RepositoryNameRepositoryName(Stringname)
}
implicit def implicit sbt.ManagedProject.moduleIDConfigurable : (sbt.ModuleID)sbt.ModuleIDConfigurablemoduleIDConfigurable(sbt.ModuleIDm: sbt.ModuleIDModuleID): sbt.ModuleIDConfigurableModuleIDConfigurable =
{
(Boolean,=> Any)Unitrequire(sbt.ModuleIDm.=> Option[String]configurations.=> BooleanisEmpty, java.lang.String("Configurations already specified for module ")"Configurations already specified for module " (Any)java.lang.String+ sbt.ModuleIDm)
sbt.ModuleIDConfigurablenew sbt.ModuleIDConfigurableModuleIDConfigurable(sbt.ModuleIDm)
}
def (String)sbt.Configurationconfig(Stringname: StringString) = (String)sbt.Configurationnew sbt.ConfigurationConfiguration(Stringname)
}
trait trait PublishConfiguration extends java.lang.Object with NotNullPublishConfiguration extends NotNullNotNull
{
def => StringresolverName: StringString
def => StringdeliveredPattern: StringString
def => Iterable[String]srcArtifactPatterns: Iterable[String]Iterable[String]
def => Iterable[sbt.ModuleID]extraDependencies: Iterable[sbt.ModuleID]Iterable[ModuleID]
def => Stringstatus: StringString
def => Option[Iterable[sbt.Configuration]]configurations: Option[Iterable[sbt.Configuration]]Option[Iterable[Configuration]]
}
trait trait BasicManagedProject extends java.lang.Object with sbt.ManagedProject with sbt.ReflectiveManagedProject with sbt.BasicDependencyPaths with ScalaObjectBasicManagedProject extends sbt.ManagedProjectManagedProject with sbt.ReflectiveManagedProjectReflectiveManagedProject with sbt.BasicDependencyPathsBasicDependencyPaths
{
import BasicManagedProject._
def => sbt.SimpleManagermanager = sbt.SimpleManagernew sbt.SimpleManagerSimpleManager(=> scala.xml.NodeSeqivyXML, Boolean(true)true, => sbt.ModuleIDprojectID, => Set[sbt.Resolver]repositories, => Iterable[sbt.Configuration]ivyConfigurations, => Option[sbt.Configuration]defaultConfiguration, => Set[sbt.ModuleID]libraryDependencies.=> List[sbt.ModuleID]toList: _*)
def => java.lang.StringoutputPattern = java.lang.String("[conf]/[artifact](-[revision]).[ext]")"[conf]/[artifact](-[revision]).[ext]"
def => scala.xml.NodeSeqivyXML: scala.xml.scala.xml.NodeSeqNodeSeq = scala.xml.object scala.xml.NodeSeqNodeSeq.=> <refinement> extends scala.xml.NodeSeqEmpty
def => List[BasicManagedProject.this.ManagedOption with ScalaObject]baseUpdateOptions = => BasicManagedProject.this.CheckScalaVersioncheckScalaVersion (BasicManagedProject.this.ManagedOption with ScalaObject)List[BasicManagedProject.this.ManagedOption with ScalaObject]:: => BasicManagedProject.this.ManagedFlagOptionValidate (BasicManagedProject.this.ManagedFlagOption)List[BasicManagedProject.this.ManagedFlagOption]:: => BasicManagedProject.this.ManagedFlagOptionSynchronize (BasicManagedProject.this.ManagedFlagOption)List[BasicManagedProject.this.ManagedFlagOption]:: => BasicManagedProject.this.ManagedFlagOptionQuietUpdate (BasicManagedProject.this.ManagedFlagOption)List[BasicManagedProject.this.ManagedFlagOption]:: => BasicManagedProject.this.ManagedFlagOptionAddScalaToolsReleases (BasicManagedProject.this.ManagedFlagOption)List[BasicManagedProject.this.ManagedFlagOption]:: object NilNil
override def => Iterable[sbt.Configuration]ivyConfigurations: Iterable[sbt.Configuration]Iterable[Configuration] =
{
val Set[sbt.Configuration]reflective = => Set[sbt.Configuration]reflectiveIvyConfigurations
Iterable[sbt.Configuration]if(=> BooleanuseMavenConfigurations)
{
val List[sbt.Configuration]base = object sbt.ConfigurationsConfigurations.=> List[sbt.Configuration]defaultMavenConfigurations (Iterable[sbt.Configuration])List[sbt.Configuration]++ Set[sbt.Configuration]reflective
val List[sbt.Configuration]allConfigurations =
List[sbt.Configuration]if(=> BooleanuseIntegrationTestConfiguration)
List[sbt.Configuration]base (Iterable[sbt.Configuration])List[sbt.Configuration]++ (sbt.Configuration*)List[sbt.Configuration]List(object sbt.ConfigurationsConfigurations.=> sbt.ConfigurationIntegrationTest)
else
List[sbt.Configuration]base
object sbt.ConfigurationsConfigurations.(Iterable[sbt.Configuration])scala.collection.immutable.Set[sbt.Configuration]removeDuplicates(List[sbt.Configuration]allConfigurations)
}
else
Set[sbt.Configuration]reflective
}
def => BooleanuseIntegrationTestConfiguration = Boolean(false)false
def => Option[sbt.Configuration]defaultConfiguration = Option[sbt.Configuration]if(=> BooleanuseMavenConfigurations) (sbt.Configuration)Some[sbt.Configuration]Some(object sbt.ConfigurationsConfigurations.=> sbt.ConfigurationCompile) else object NoneNone
def => BooleanuseMavenConfigurations = Boolean(false)false
def => Seq[BasicManagedProject.this.ManagedOption]updateOptions: Seq[BasicManagedProject.this.ManagedOption]Seq[ManagedOption] =
{
val sbt.SimpleManagerm = => sbt.SimpleManagermanager
Seq[BasicManagedProject.this.ManagedOption]if(sbt.SimpleManagerm.=> sbt.ModuleID*dependencies.=> BooleanisEmpty (Boolean)Boolean&& sbt.SimpleManagerm.=> Iterable[sbt.Resolver]resolvers.=> BooleanisEmpty (Boolean)Boolean&& => scala.xml.NodeSeqivyXML.=> BooleanisEmpty)
=> List[BasicManagedProject.this.ManagedOption with ScalaObject]baseUpdateOptions
else
(sbt.Manager)BasicManagedProject.this.LibraryManagerLibraryManager(sbt.SimpleManagerm) (BasicManagedProject.this.ManagedOption with ScalaObject)List[BasicManagedProject.this.ManagedOption with ScalaObject]:: => List[BasicManagedProject.this.ManagedOption with ScalaObject]baseUpdateOptions
}
def => BooleanincludeProvidedWithCompile = Boolean(true)true
def => BooleandefaultConfigurationExtensions = Boolean(true)true
def => BooleancheckExplicitScalaDependencies = Boolean(true)true
def => BooleanfilterScalaJars = Boolean(true)true
def => Iterable[sbt.Configuration]checkScalaInConfigurations: Iterable[sbt.Configuration]Iterable[Configuration] = => Iterable[sbt.Configuration]ivyConfigurations
def => BasicManagedProject.this.CheckScalaVersioncheckScalaVersion = (Iterable[sbt.Configuration],Boolean,Boolean)BasicManagedProject.this.CheckScalaVersionCheckScalaVersion(=> Iterable[sbt.Configuration]checkScalaInConfigurations, => BooleancheckExplicitScalaDependencies, => BooleanfilterScalaJars)
override def (sbt.Configuration,Boolean)sbt.PathFindermanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration, BooleanuseDefaultFallback: BooleanBoolean) =
{
import Configurations.{Compile, Provided, Runtime, Test}
val sbt.PathFindersuperClasspath = (sbt.Configuration,Boolean)sbt.PathFindersuper.(sbt.Configuration,Boolean)sbt.PathFindermanagedClasspath(sbt.Configurationconfig, BooleanuseDefaultFallback)
sbt.PathFinderif(sbt.Configurationconfig (AnyRef)Boolean== => sbt.ConfigurationCompile (Boolean)Boolean&& => BooleanincludeProvidedWithCompile)
sbt.PathFindersuperClasspath (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration,Boolean)sbt.PathFindersuper.managedClasspath(=> sbt.ConfigurationProvided, Boolean(false)false)
else sbt.PathFinderif(=> BooleandefaultConfigurationExtensions (Boolean)Boolean&& sbt.Configurationconfig (AnyRef)Boolean== => sbt.ConfigurationRuntime)
sbt.PathFindersuperClasspath (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration,Boolean)sbt.PathFindersuper.managedClasspath(=> sbt.ConfigurationCompile, Boolean(false)false)
else sbt.PathFinderif(=> BooleandefaultConfigurationExtensions (Boolean)Boolean&& sbt.Configurationconfig (AnyRef)Boolean== => sbt.ConfigurationTest)
sbt.PathFindersuperClasspath (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration,Boolean)sbt.PathFindersuper.managedClasspath(=> sbt.ConfigurationCompile, Boolean(false)false) (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration,Boolean)sbt.PathFindersuper.managedClasspath(=> sbt.ConfigurationRuntime, Boolean(false)false)
else
sbt.PathFindersuperClasspath
}
protected def => BasicManagedProject.this.TaskupdateAction = (String,sbt.Path,=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskupdateTask(=> java.lang.StringoutputPattern, => sbt.PathmanagedDependencyPath, => Seq[BasicManagedProject.this.ManagedOption]updateOptions) (String)BasicManagedProject.this.TaskdescribedAs => java.lang.StringUpdateDescription
protected def => BasicManagedProject.this.TaskcleanLibAction = (sbt.Path)BasicManagedProject.this.TaskcleanLibTask(=> sbt.PathmanagedDependencyPath) (String)BasicManagedProject.this.TaskdescribedAs => java.lang.StringCleanLibDescription
protected def => BasicManagedProject.this.TaskcleanCacheAction = (sbt.Path,=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskcleanCacheTask(=> sbt.PathmanagedDependencyPath, => Seq[BasicManagedProject.this.ManagedOption]updateOptions) (String)BasicManagedProject.this.TaskdescribedAs => java.lang.StringCleanCacheDescription
protected def => List[sbt.ModuleID]deliverProjectDependencies =
{
val scala.collection.mutable.ListBuffer[sbt.ModuleID]interDependencies = scala.collection.mutable.ListBuffer[sbt.ModuleID]new scala.collection.mutable.scala.collection.mutable.ListBuffer[sbt.ModuleID]ListBuffer[ModuleID]
=> Iterable[sbt.Project]dependencies.((sbt.Project) => Unit)Unitforeach(sbt.Projectdep => sbt.Projectdep Unitmatch { Unitcase sbt.ManagedProjectmp: sbt.ManagedProjectManagedProject => scala.collection.mutable.ListBuffer[sbt.ModuleID]interDependencies (sbt.ModuleID)Unit+= sbt.ManagedProjectmp.=> sbt.ModuleIDprojectID; Unitcase _ => Unit() })
scala.collection.mutable.ListBuffer[sbt.ModuleID]interDependencies.=> List[sbt.ModuleID]readOnly
}
protected def => BasicManagedProject.this.TaskmakePomAction = (sbt.Path,Iterable[sbt.ModuleID],=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskmakePomTask(=> sbt.PathoutputPath (String)sbt.Path/ java.lang.String("pom.xml")"pom.xml", => List[sbt.ModuleID]deliverProjectDependencies, => Seq[BasicManagedProject.this.ManagedOption]updateOptions)
protected def => BasicManagedProject.this.TaskdeliverLocalAction = (sbt.PublishConfiguration,=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskdeliverTask(=> BasicManagedProject.this.DefaultPublishConfigurationpublishLocalConfiguration, => Seq[BasicManagedProject.this.ManagedOption]updateOptions)
protected def => BasicManagedProject.this.TaskpublishLocalAction = (sbt.PublishConfiguration,=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskpublishTask(=> BasicManagedProject.this.DefaultPublishConfigurationpublishLocalConfiguration, => Seq[BasicManagedProject.this.ManagedOption]updateOptions) (BasicManagedProject.this.ManagedTask*)BasicManagedProject.this.TaskdependsOn(=> BasicManagedProject.this.TaskdeliverLocal)
protected def => BasicManagedProject.this.DefaultPublishConfigurationpublishLocalConfiguration = BasicManagedProject.this.DefaultPublishConfigurationnew BasicManagedProject.this.DefaultPublishConfigurationDefaultPublishConfiguration(java.lang.String("local")"local", java.lang.String("release")"release")
protected class class DefaultPublishConfiguration extends java.lang.Object with sbt.PublishConfiguration with ScalaObjectDefaultPublishConfiguration(val StringresolverName: StringString, val Stringstatus: StringString) extends sbt.PublishConfigurationPublishConfiguration
{
protected def => sbt.PathdeliveredPathPattern = => sbt.PathoutputPath (String)sbt.Path/ java.lang.String("[artifact]-[revision].[ext]")"[artifact]-[revision].[ext]"
def => StringdeliveredPattern = => sbt.PathdeliveredPathPattern.=> StringrelativePath
def => Iterable[String]srcArtifactPatterns: Iterable[String]Iterable[String] =
{
val List[sbt.Path]pathPatterns =
(=> sbt.PathoutputPath (String)sbt.Path/ java.lang.String("[artifact]-[revision]-[type].[ext]")"[artifact]-[revision]-[type].[ext]") (sbt.Path)List[sbt.Path]::
(=> sbt.PathoutputPath (String)sbt.Path/ java.lang.String("[artifact]-[revision].[ext]")"[artifact]-[revision].[ext]") (sbt.Path)List[sbt.Path]::
object NilNil
List[sbt.Path]pathPatterns.((sbt.Path) => String)List[String]map(sbt.Path_.=> StringrelativePath)
}
def => Iterable[sbt.ModuleID]extraDependencies: Iterable[sbt.ModuleID]Iterable[ModuleID] = object NilNil
def => Option[Iterable[sbt.Configuration]]configurations: Option[Iterable[sbt.Configuration]]Option[Iterable[Configuration]] = object NoneNone
}
lazy val BasicManagedProject.this.Taskupdate = => BasicManagedProject.this.TaskupdateAction
lazy val BasicManagedProject.this.TaskmakePom = => BasicManagedProject.this.TaskmakePomAction
lazy val BasicManagedProject.this.TaskdeliverLocal = => BasicManagedProject.this.TaskdeliverLocalAction
lazy val BasicManagedProject.this.TaskpublishLocal = => BasicManagedProject.this.TaskpublishLocalAction
lazy val BasicManagedProject.this.TaskcleanLib = => BasicManagedProject.this.TaskcleanLibAction
lazy val BasicManagedProject.this.TaskcleanCache = => BasicManagedProject.this.TaskcleanCacheAction
}
object object sbt.BasicManagedProjectBasicManagedProject
{
val java.lang.StringUpdateDescription =
java.lang.String("Resolves and retrieves automatically managed dependencies.")"Resolves and retrieves automatically managed dependencies."
val java.lang.StringCleanLibDescription =
java.lang.String("Deletes the managed library directory.")"Deletes the managed library directory."
val java.lang.StringCleanCacheDescription =
java.lang.String("Deletes the cache of artifacts downloaded for automatically managed dependencies.")"Deletes the cache of artifacts downloaded for automatically managed dependencies."
}
trait trait BasicDependencyPaths extends java.lang.Object with sbt.Project with ScalaObjectBasicDependencyPaths extends sbt.ProjectProject
{
import BasicDependencyPaths._
def => java.lang.StringdependencyDirectoryName = => java.lang.StringDefaultDependencyDirectoryName
def => java.lang.StringmanagedDirectoryName = => java.lang.StringDefaultManagedDirectoryName
def => sbt.PathdependencyPath = implicit sbt.Project.path : (String)sbt.Pathpath(=> java.lang.StringdependencyDirectoryName)
def => sbt.PathmanagedDependencyPath = implicit sbt.Project.path : (String)sbt.Pathpath(=> java.lang.StringmanagedDirectoryName)
}
object object sbt.BasicDependencyPathsBasicDependencyPaths
{
val java.lang.StringDefaultManagedDirectoryName = java.lang.String("lib_managed")"lib_managed"
val java.lang.StringDefaultDependencyDirectoryName = java.lang.String("lib")"lib"
}
object object sbt.StringUtilitiesStringUtilities
{
def (String,String)UnitnonEmpty(Strings: StringString, Stringlabel: StringString)
{
(Boolean,=> Any)Unitrequire(Strings.()java.lang.Stringtrim.()Intlength (Int)Boolean> Int(0)0, Stringlabel (Any)java.lang.String+ java.lang.String(" cannot be empty.")" cannot be empty.")
}
}
import StringUtilities.nonEmpty
final class class GroupID extends java.lang.Object with NotNull with ScalaObjectGroupID private[sbt] (StringgroupID: StringString) extends NotNullNotNull
{
def (String)sbt.GroupArtifactID% (StringartifactID: StringString) =
{
(String,String)UnitnonEmpty(StringartifactID, java.lang.String("Artifact ID")"Artifact ID")
sbt.GroupArtifactIDnew sbt.GroupArtifactIDGroupArtifactID(StringgroupID, StringartifactID)
}
}
final class class GroupArtifactID extends java.lang.Object with NotNull with ScalaObjectGroupArtifactID private[sbt] (StringgroupID: StringString, StringartifactID: StringString) extends NotNullNotNull
{
def (String)sbt.ModuleID% (Stringrevision: StringString): sbt.ModuleIDModuleID =
{
(String,String)UnitnonEmpty(Stringrevision, java.lang.String("Revision")"Revision")
(String,String,String,Option[String])sbt.ModuleIDModuleID(StringgroupID, StringartifactID, Stringrevision, object NoneNone)
}
}
final class class ModuleIDConfigurable extends java.lang.Object with NotNull with ScalaObjectModuleIDConfigurable private[sbt] (sbt.ModuleIDmoduleID: sbt.ModuleIDModuleID) extends NotNullNotNull
{
def (String)sbt.ModuleID% (Stringconfigurations: StringString): sbt.ModuleIDModuleID =
{
(String,String)UnitnonEmpty(Stringconfigurations, java.lang.String("Configurations")"Configurations")
import moduleID._
(String,String,String,Option[String])sbt.ModuleIDModuleID(=> Stringorganization, => Stringname, => Stringrevision, (String)Some[String]Some(Stringconfigurations))
}
}
final class class RepositoryName extends java.lang.Object with NotNull with ScalaObjectRepositoryName private[sbt] (Stringname: StringString) extends NotNullNotNull
{
def (String)sbt.MavenRepositoryat (Stringlocation: StringString) =
{
(String,String)UnitnonEmpty(Stringlocation, java.lang.String("Repository location")"Repository location")
sbt.MavenRepositorynew sbt.MavenRepositoryMavenRepository(Stringname, Stringlocation)
}
}
import scala.collection.{Map, mutable}
trait trait ReflectiveTasks extends java.lang.Object with sbt.Project with ScalaObjectReflectiveTasks extends sbt.ProjectProject
{
def => scala.collection.Map[String,ReflectiveTasks.this.Task]tasks: scala.collection.Map[String,ReflectiveTasks.this.Task]Map[String, Task] = => scala.collection.Map[String,ReflectiveTasks.this.Task]reflectiveTaskMappings
def => scala.collection.Map[String,ReflectiveTasks.this.Task]reflectiveTaskMappings : scala.collection.Map[String,ReflectiveTasks.this.Task]Map[String, Task] = object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[ReflectiveTasks.this.Task])scala.collection.Map[String,ReflectiveTasks.this.Task]reflectiveMappings[ReflectiveTasks.this.TaskTask](sbt.ReflectiveTasksthis)
}
trait trait ReflectiveMethods extends java.lang.Object with sbt.Project with ScalaObjectReflectiveMethods extends sbt.ProjectProject
{
def => scala.collection.Map[String,ReflectiveMethods.this.MethodTask]methods: scala.collection.Map[String,ReflectiveMethods.this.MethodTask]Map[String, MethodTask] = => scala.collection.Map[String,ReflectiveMethods.this.MethodTask]reflectiveMethodMappings
def => scala.collection.Map[String,ReflectiveMethods.this.MethodTask]reflectiveMethodMappings : scala.collection.Map[String,ReflectiveMethods.this.MethodTask]Map[String, MethodTask] = object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[ReflectiveMethods.this.MethodTask])scala.collection.Map[String,ReflectiveMethods.this.MethodTask]reflectiveMappings[ReflectiveMethods.this.MethodTaskMethodTask](sbt.ReflectiveMethodsthis)
}
trait trait ReflectiveModules extends java.lang.Object with sbt.Project with ScalaObjectReflectiveModules extends sbt.ProjectProject
{
override def => scala.collection.Map[String,sbt.Project]subProjects: scala.collection.Map[String,sbt.Project]Map[String, Project] = => scala.collection.Map[String,sbt.Project]reflectiveModuleMappings
def => scala.collection.Map[String,sbt.Project]reflectiveModuleMappings : scala.collection.Map[String,sbt.Project]Map[String, Project] = object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[sbt.Project])scala.collection.Map[String,sbt.Project]reflectiveMappings[sbt.ProjectProject](sbt.ReflectiveModulesthis)
}
trait trait ReflectiveProject extends java.lang.Object with sbt.ReflectiveModules with sbt.ReflectiveTasks with sbt.ReflectiveMethodsReflectiveProject extends sbt.ReflectiveModulesReflectiveModules with sbt.ReflectiveTasksReflectiveTasks with sbt.ReflectiveMethodsReflectiveMethods
class class ParentProject extends java.lang.Object with sbt.BasicDependencyProject with ScalaObjectParentProject(val sbt.ProjectInfoinfo: sbt.ProjectInfoProjectInfo) extends sbt.BasicDependencyProjectBasicDependencyProject
{
def => Collection[sbt.Project]dependencies = => sbt.ProjectInfoinfo.=> Iterable[sbt.Project]dependencies (Iterable[sbt.Project])Collection[sbt.Project]++ => scala.collection.Map[String,sbt.Project]subProjects.=> Iterator[sbt.Project]values.=> List[sbt.Project]toList
override def => List[sbt.Path]outputDirectories = => sbt.PathmanagedDependencyPath (sbt.Path)List[sbt.Path]:: => sbt.PathoutputPath (sbt.Path)List[sbt.Path]:: object NilNil
def (sbt.Configuration)sbt.PathFinderfullUnmanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration) = => sbt.PathFinderunmanagedClasspath
}
object object sbt.ReflectiveReflective
{
def [T](AnyRef)(implicit scala.reflect.Manifest[T])scala.collection.Map[String,T]reflectiveMappings[>: Nothing <: AnyT](AnyRefobj: AnyRefAnyRef)(implicit scala.reflect.Manifest[T]m: scala.reflect.scala.reflect.Manifest[T]Manifest[T]): scala.collection.Map[String,T]Map[String, T] =
{
val scala.collection.mutable.OpenHashMap[String,T]mappings = ()scala.collection.mutable.OpenHashMap[String,T]new mutable.scala.collection.mutable.OpenHashMap[String,T]OpenHashMap[String, T]
for ((((String, T)) => Unit)Unit(Stringname, Tvalue) <- object sbt.ReflectUtilitiesReflectUtilities.(AnyRef)(implicit scala.reflect.Manifest[T])scala.collection.Map[String,T]allVals[TT](AnyRefobj))
scala.collection.mutable.OpenHashMap[String,T]mappings(object sbt.ReflectUtilitiesReflectUtilities.(String,Char)StringtransformCamelCase(Stringname, Char('-')'-')) = Tvalue
scala.collection.mutable.OpenHashMap[String,T]mappings
}
}
trait trait ReflectiveLibraryDependencies extends java.lang.Object with sbt.ManagedProject with ScalaObjectReflectiveLibraryDependencies extends sbt.ManagedProjectManagedProject
{
def => Iterable[sbt.ModuleID]excludeIDs: Iterable[sbt.ModuleID]Iterable[ModuleID] = => sbt.ModuleIDprojectID (sbt.ModuleID)List[sbt.ModuleID]:: object NilNil
def => Set[sbt.ModuleID]libraryDependencies: Set[sbt.ModuleID]Set[ModuleID] = => Set[sbt.ModuleID]reflectiveLibraryDependencies
def => Set[sbt.ModuleID]reflectiveLibraryDependencies : Set[sbt.ModuleID]Set[ModuleID] = (sbt.ModuleID*)scala.collection.immutable.Set[sbt.ModuleID]Set(object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[sbt.ModuleID])scala.collection.Map[String,sbt.ModuleID]reflectiveMappings[sbt.ModuleIDModuleID](sbt.ReflectiveLibraryDependenciesthis).=> Iterator[sbt.ModuleID]values.=> List[sbt.ModuleID]toList: _*) (Iterable[sbt.ModuleID])scala.collection.immutable.Set[sbt.ModuleID]-- => Iterable[sbt.ModuleID]excludeIDs
}
trait trait ReflectiveConfigurations extends java.lang.Object with sbt.Project with ScalaObjectReflectiveConfigurations extends sbt.ProjectProject
{
def => Iterable[sbt.Configuration]ivyConfigurations: Iterable[sbt.Configuration]Iterable[Configuration] = => Set[sbt.Configuration]reflectiveIvyConfigurations
def => Set[sbt.Configuration]reflectiveIvyConfigurations: Set[sbt.Configuration]Set[Configuration] = object sbt.ConfigurationsConfigurations.(Iterable[sbt.Configuration])scala.collection.immutable.Set[sbt.Configuration]removeDuplicates(object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[sbt.Configuration])scala.collection.Map[String,sbt.Configuration]reflectiveMappings[sbt.ConfigurationConfiguration](sbt.ReflectiveConfigurationsthis).=> Iterator[sbt.Configuration]values.=> List[sbt.Configuration]toList)
}
trait trait ReflectiveRepositories extends java.lang.Object with sbt.Project with ScalaObjectReflectiveRepositories extends sbt.ProjectProject
{
def => Set[sbt.Resolver]repositories: Set[sbt.Resolver]Set[Resolver] = => Set[sbt.Resolver]reflectiveRepositories
def => Set[sbt.Resolver]reflectiveRepositories: Set[sbt.Resolver]Set[Resolver] = (sbt.Resolver*)scala.collection.immutable.Set[sbt.Resolver]Set(object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[sbt.Resolver])scala.collection.Map[String,sbt.Resolver]reflectiveMappings[sbt.ResolverResolver](sbt.ReflectiveRepositoriesthis).=> Iterator[sbt.Resolver]values.=> List[sbt.Resolver]toList: _*)
}
trait trait ReflectiveManagedProject extends java.lang.Object with sbt.ReflectiveProject with sbt.ReflectiveRepositories with sbt.ReflectiveLibraryDependencies with sbt.ReflectiveConfigurationsReflectiveManagedProject extends sbt.ReflectiveProjectReflectiveProject with sbt.ReflectiveRepositoriesReflectiveRepositories with sbt.ReflectiveLibraryDependenciesReflectiveLibraryDependencies with sbt.ReflectiveConfigurationsReflectiveConfigurations