Type Members

1.  abstract class AutoPlugin extends Basic with PluginsFunctions

   An AutoPlugin defines a group of settings and the conditions where the settings are automatically added to a build (called "activation").

   An AutoPlugin defines a group of settings and the conditions where the settings are automatically added to a build (called "activation"). The requires and trigger methods together define the conditions, and a method like projectSettings defines the settings to add.

   Steps for plugin authors:

   1. Determine if the AutoPlugin should automatically be activated when all requirements are met, or should be opt-in.
   2. Determine the AutoPlugins that, when present (or absent), act as the requirements for the AutoPlugin.
   3. Determine the settings/configurations to that the AutoPlugin injects when activated.
   4. Determine the keys and other names to be automatically imported to *.sbt scripts.

   For example, the following will automatically add the settings in projectSettings to a project that has both the Web and Javascript plugins enabled.

   object MyPlugin extends sbt.AutoPlugin {
     override def requires = Web && Javascript
     override def trigger = allRequirements
     override def projectSettings = Seq(...)
   
     object autoImport {
       lazy val obfuscate = taskKey[Seq[File]]("Obfuscates the source.")
     }
   }

   Steps for users:

   1. Add dependencies on plugins in project/plugins.sbt as usual with addSbtPlugin
   2. Add key plugins to projects, which will automatically select the plugin + dependent plugin settings to add for those projects.
   3. Exclude plugins, if desired.

   For example, given plugins Web and Javascript (perhaps provided by plugins added with addSbtPlugin),

   myProject.enablePlugins(Web && Javascript)

   will activate MyPlugin defined above and have its settings automatically added. If the user instead defines

   myProject.enablePlugins(Web && Javascript).disablePlugins(MyPlugin)

   then the MyPlugin settings (and anything that activates only when MyPlugin is activated) will not be added.

2.  final class AutoPluginException extends RuntimeException

   An error that occurs when auto-plugins aren't configured properly.

   An error that occurs when auto-plugins aren't configured properly. It translates the error from the underlying logic system to be targeted at end users.

3.  abstract class BackgroundJobService extends Closeable
4.  trait BuildCommon extends AnyRef
5.  trait BuildExtra extends BuildCommon with DefExtra
6.  sealed trait ClassLoaderLayeringStrategy extends AnyRef

   Represents a ClassLoader layering strategy.

   Represents a ClassLoader layering strategy. By providing an instance of ClassLoaderLayeringStrategy, users can configure the strategy that they want to use in various sbt tasks, most importantly Keys.run and Keys.test. This setting is only relevant if fork := false in the task for which we obtain a ClassLoaderLayeringStrategy.

   ClassLoaders can be composed of multiple ClassLoaders to form a graph for loading a class. The different portions of the graph may be cached and reused to minimize both the memory taken up by ClassLoaders (and the classes that they load) and the startup time for tasks like test and run. For example, the scala library is large and takes a while just to load the classes in predef. The Keys.scalaInstance task provides access to a classloader that can load all of the java bootstrap classes and scala.*. Supposing that we want to run code in a jar containing scala code called "foo_2.12.jar" in the base directory and that we have a scala instance in scope and suppose further that "foo_2.12.jar" contains a main method in the class foo.Main, then we can invoke foo.Main.main like so

   val fooJarFile = new File("foo_2.12.jar")
   val classLoader = new URLClassLoader(
     Array(fooJarFile.toURI.toURL), scalaInstance.loaderLibraryOnly)
   val main = classLoader.loadClass("foo.Main").getDeclaredMethod("main", classOf[Array[String]])
   main.invoke(null, Array.empty[String])

   Now suppose that we have an alternative jar "foo_alt_2.12.jar" that also provides foo.Main, then we can run that main method:

   val fooJarFile = new File("foo_alt_2.12.jar")
   val altClassLoader = new URLClassLoader(
     Array(fooAltJarFile.toURI.toURL), scalaInstance.loaderLibraryOnly)
   val altMain = classLoader.loadClass("foo.Main").getDeclaredMethod("main", classOf[Array[String]])
   altMain.invoke(null, Array.empty[String])

   In the second invocation, the scala library will have already been loaded by the scalaInstance.loaderLibraryOnly ClassLoader. This can reduce the startup time by O(500ms) and prevents an accumulation of scala related Class objects. Note that these ClassLoaders should only be used at a code boundary such that their loaded classes do not leak outside of the defining scope. This is because the layered class loaders can create mutually incompatible classes. For example, in the example above, suppose that there is a class foo.Bar provided by both "foo_2.12.jar" and "foo_2.12.jar" and that both also provide a static method "foo.Foo$.bar" that returns an instance of foo.Bar, then the following code will not work:

   Thread.currentThread.setContextClassLoader(altClassLoader)
   val bar: Object = classLoader.loadClass("foo.Foo$").getDeclaredMethod("bar").invoke(null)
   val barTyped: foo.Bar = bar.asInstanceOf[foo.Bar]
   // throws ClassCastException because the thread context class loader is altClassLoader, but
   // but bar was loaded by classLoader.

   In general, this should only happen if the user explicitly overrides the thread context ClassLoader or uses reflection to manipulate classes loaded by different loaders.

7.  sealed trait ClasspathDep[PR <: ProjectReference] extends AnyRef
8.  final case class ClasspathDependency(project: ProjectReference, configuration: Option[String]) extends ClasspathDep[ProjectReference] with Product with Serializable
9.  trait CommandLineUIService extends InteractionService
10.  trait CompositeProject extends AnyRef
11.  final class ConsoleMain extends AppMain
12.  trait DefExtra extends AnyRef
13.  sealed trait EvaluateTaskConfig extends AnyRef

    The new API for running tasks.

    The new API for running tasks.

    This represents all the hooks possible when running the task engine. We expose this trait so that we can, in a binary compatible way, modify what is used inside this configuration and how to construct it.

14.  final case class Extracted(structure: BuildStructure, session: SessionSettings, currentRef: ProjectRef)(implicit showKey: Show[Def.ScopedKey[_]]) extends Product with Serializable
15.  abstract class InteractionService extends AnyRef

    InteractionService provides an abstration over standard input.

    InteractionService provides an abstration over standard input. In the future this could be used to ask for inputs from other forms of sbt clients such as thin clients and IDEs.

16.  final class JavaVersion extends Serializable
17.  abstract class JobHandle extends AnyRef
18.  trait OptionSyntax extends AnyRef
19.  final case class PluginData(dependencyClasspath: Seq[Attributed[File]], definitionClasspath: Seq[Attributed[File]], resolvers: Option[Vector[Resolver]], report: Option[UpdateReport], scalacOptions: Seq[String]) extends Product with Serializable
20.  sealed abstract class PluginTrigger extends Serializable

    Type for AutoPlugin's trigger method.

    Type for AutoPlugin's trigger method. Determines whether an AutoPlugin will be activated for a project when the requires clause is satisfied.

21.  sealed trait Plugins extends AnyRef

    An expression that matches AutoPlugins.

22.  sealed trait PluginsFunctions extends AnyRef
23.  sealed trait Project extends ProjectDefinition[ProjectReference] with CompositeProject
24.  sealed trait ProjectDefinition[PR <: ProjectReference] extends AnyRef
25.  trait ProjectExtra extends AnyRef
26.  sealed abstract class ProjectOrigin extends Serializable

    Indicate whether the project was created organically, synthesized by a plugin, or is a "generic root" project supplied by sbt when a project doesn't exist for file(".").

27.  final case class ResolvedClasspathDependency(project: ProjectRef, configuration: Option[String]) extends ClasspathDep[ProjectRef] with Product with Serializable
28.  sealed trait ResolvedProject extends ProjectDefinition[ProjectRef]
29.  class RichURI extends AnyRef

    Extends URI with additional convenience methods.

30.  trait RunningTaskEngine extends AnyRef

    An API that allows you to cancel executing tasks upon some signal.

    An API that allows you to cancel executing tasks upon some signal.

    For example, this is implemented by the TaskEngine; invoking cancelAndShutdown() allows you to cancel the current task execution.

31.  final case class ScopedKeyData[A](scoped: Def.ScopedKey[A], value: Any) extends Product with Serializable
32.  final class ScriptMain extends AppMain
33.  final class StateTransform extends AnyRef
34.  trait TaskCancellationStrategy extends AnyRef

    A strategy for being able to cancel tasks.

    A strategy for being able to cancel tasks.

    Implementations of this trait determine what will trigger cancel() for the task engine, providing in the start method.

    All methods on this API are expected to be called from the same thread.

35.  final class xMain extends AppMain

    This class is the entry point for sbt.