Type Members

1.  sealed trait Action[T] extends AnyRef

   Defines a task computation

2.  final case class ApplicationID(groupID: String, name: String, version: String, mainClass: String, components: Seq[String], crossVersionedValue: CrossValue, extra: Seq[File]) extends xsbti.ApplicationID with Product with Serializable
3.  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.

4.  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.

5.  abstract class BackgroundJobService extends Closeable
6.  trait BuildCommon extends AnyRef
7.  trait BuildExtra extends BuildCommon with DefExtra
8.  final case class BuildRef(build: URI) extends BuildReference with ResolvedReference with Product with Serializable

   Uniquely identifies a build by a URI.

9.  sealed trait BuildReference extends Reference

   Identifies a build.

10.  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.

11.  sealed trait ClasspathDep[PR <: ProjectReference] extends AnyRef
12.  final case class ClasspathDependency(project: ProjectReference, configuration: Option[String]) extends ClasspathDep[ProjectReference] with Product with Serializable
13.  sealed trait Command extends AnyRef

    An operation that can be executed from the sbt console.

    An operation that can be executed from the sbt console.

    The operation takes a State as a parameter and returns a State. This means that a command can look at or modify other sbt settings, for example. Typically you would resort to a command when you need to do something that's impossible in a regular task.

14.  trait CommandDefinitions extends (State) ⇒ State
15.  trait CommandLineUIService extends InteractionService
16.  final class CommandSource extends Serializable
17.  sealed trait Completed extends AnyRef
18.  trait CompletionService[A, R] extends AnyRef
19.  trait CompositeProject extends AnyRef
20.  trait ConcurrentRestrictions[A] extends AnyRef

    Describes restrictions on concurrent execution for a set of tasks.

    Describes restrictions on concurrent execution for a set of tasks.

    A

    the type of a task

21.  final case class ConfigKey(name: String) extends Product with Serializable
22.  sealed abstract class ConnectionType extends Serializable
23.  final class Console extends AnyRef
24.  final class ConsoleMain extends AppMain
25.  trait DefExtra extends AnyRef
26.  sealed trait DelegateIndex extends AnyRef
27.  final case class DependsOn[T](in: Task[T], deps: Seq[Task[_]]) extends Action[T] with Product with Serializable

    A computation in that requires other tasks deps to be evaluated first.

28.  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.

29.  final class Exec extends Serializable
30.  trait ExecuteProgress[F[_]] extends AnyRef

    Processes progress events during task execution.

    Processes progress events during task execution. All methods are called from the same thread except started and finished, which is called from the executing task's thread. All methods should return quickly to avoid task execution overhead.

31.  final case class Exit(code: Int) extends xsbti.Exit with Product with Serializable
32.  final case class Extracted(structure: BuildStructure, session: SessionSettings, currentRef: ProjectRef)(implicit showKey: Show[Def.ScopedKey[_]]) extends Product with Serializable
33.  final case class FlatMapped[T, K[L[x]]](in: K[Task], f: (K[Result]) ⇒ Task[T], alist: AList[K]) extends Action[T] with Product with Serializable

    Computes another task to evaluate based on results from evaluating other tasks.

34.  final class Fork extends AnyRef

    Represents a command that can be forked.

35.  final class ForkConfiguration extends Serializable
36.  final class ForkMain extends AnyRef
37.  final class ForkOptions extends Serializable

    Configures forking.

38.  class ForkRun extends ScalaRun
39.  sealed abstract final class ForkTags extends Enum[ForkTags]
40.  trait Help extends AnyRef
41.  trait Identity extends AnyRef
42.  trait Import extends AnyRef
43.  final case class Inc(cause: Incomplete) extends Result[Nothing] with Product with Serializable

    Indicates the task did not complete normally and so it does not have a value.

44.  final case class Incomplete(node: Option[AnyRef], tpe: Incomplete.Value = Error, message: Option[String] = None, causes: Seq[Incomplete] = Nil, directCause: Option[Throwable] = None) extends Exception with UnprintableException with Product with Serializable

    Describes why a task did not complete.

    Describes why a task did not complete.

    node

    the task that did not complete that is described by this Incomplete instance

    tpe

    whether the task was incomplete because of an error or because it was skipped. Only Error is actually used and Skipped may be removed in the future.

    message

    an optional error message describing this incompletion

    causes

    a list of incompletions that prevented node from completing

    directCause

    the exception that caused node to not complete

45.  final case class Info[T](attributes: AttributeMap = AttributeMap.empty, post: (T) ⇒ AttributeMap = Info.defaultAttributeMap) extends Product with Serializable

    Used to provide information about a task, such as the name, description, and tags for controlling concurrent execution.

    Used to provide information about a task, such as the name, description, and tags for controlling concurrent execution.

    attributes

    Arbitrary user-defined key/value pairs describing this task

    post

    a transformation that takes the result of evaluating this task and produces user-defined key/value pairs.

46.  sealed trait InitializeImplicits extends InitializeImplicits0
47.  sealed trait InitializeImplicits0 extends AnyRef
48.  sealed trait InputKey[T] extends Scoped with sbt.Def.KeyedInitialize[InputTask[T]] with ScopingSetting[InputKey[T]] with DefinableSetting[InputTask[T]]

    Identifies an input task.

    Identifies an input task. An input task parses input and produces a task to run. It consists of three parts: the scope, the name, and the type of the value produced by an input task associated with this key. The scope is represented by a value of type Scope. The name and the type are represented by a value of type AttributeKey[InputTask[T]]. Instances are constructed using the companion object.

49.  final class InputTask[T] extends AnyRef

    Parses input and produces a task to run.

    Parses input and produces a task to run. Constructed using the companion object.

50.  abstract class InteractionService extends AnyRef

    InteractionService provides an abstraction over standard input.

    InteractionService provides an abstraction 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.

51.  final class JavaVersion extends Serializable
52.  abstract class JobHandle extends AnyRef
53.  final case class Join[T, U](in: Seq[Task[U]], f: (Seq[Result[U]]) ⇒ Either[Task[T], T]) extends Action[T] with Product with Serializable

    A computation that operates on the results of a homogeneous list of other tasks.

    A computation that operates on the results of a homogeneous list of other tasks. It can either return another task to be evaluated or the final value.

54.  final case class LocalProject(project: String) extends ProjectReference with Product with Serializable

    Identifies a project in the current build context.

55.  final case class Mapped[T, K[L[x]]](in: K[Task], f: (K[Result]) ⇒ T, alist: AList[K]) extends Action[T] with Product with Serializable

    Applies a function to the result of evaluating a heterogeneous list of other tasks.

56.  trait Node[A[_], T] extends AnyRef

    Represents a task node in a format understood by the task evaluation engine Execute.

    Represents a task node in a format understood by the task evaluation engine Execute.

    A

    the task type constructor

    T

    the type computed by this node

57.  trait OptionSyntax extends AnyRef
58.  sealed abstract class OutputStrategy extends AnyRef

    Configures where the standard output and error streams from a forked process go.

59.  sealed trait PackageOption extends AnyRef
60.  final case class PluginData(dependencyClasspath: Seq[Attributed[File]], definitionClasspath: Seq[Attributed[File]], resolvers: Option[Vector[Resolver]], report: Option[UpdateReport], scalacOptions: Seq[String], unmanagedSourceDirectories: Seq[File], unmanagedSources: Seq[File], managedSourceDirectories: Seq[File], managedSources: Seq[File], buildTarget: Option[BuildTargetIdentifier]) extends Product with Serializable
61.  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.

62.  sealed trait Plugins extends AnyRef

    An expression that matches AutoPlugins.

63.  sealed trait PluginsFunctions extends AnyRef
64.  sealed trait Project extends ProjectDefinition[ProjectReference] with CompositeProject
65.  sealed trait ProjectDefinition[PR <: ProjectReference] extends AnyRef
66.  trait ProjectExtra extends AnyRef
67.  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(".").

68.  final case class ProjectRef(build: URI, project: String) extends ProjectReference with ResolvedReference with Product with Serializable

    Uniquely references a project by a URI and a project identifier String.

69.  sealed trait ProjectReference extends Reference

    Identifies a project.

70.  final class PromiseWrap[A] extends AnyRef
71.  final case class Pure[T](f: () ⇒ T, inline: Boolean) extends Action[T] with Product with Serializable

    A direct computation of a value.

    A direct computation of a value. If inline is true, f will be evaluated on the scheduler thread without the overhead of normal scheduling when possible. This is intended as an optimization for already evaluated values or very short pure computations.

72.  final case class Reboot(scalaVersion: String, argsList: Seq[String], app: xsbti.ApplicationID, baseDirectory: File) extends xsbti.Reboot with Product with Serializable
73.  sealed trait Reference extends AnyRef

    Identifies a project or build.

74.  final case class ResolvedClasspathDependency(project: ProjectRef, configuration: Option[String]) extends ClasspathDep[ProjectRef] with Product with Serializable
75.  sealed trait ResolvedProject extends ProjectDefinition[ProjectRef]
76.  sealed trait ResolvedReference extends Reference

    A fully resolved, unique identifier for a project or build.

77.  sealed trait Result[+T] extends AnyRef

    Result of completely evaluating a task.

78.  class RichURI extends AnyRef

    Extends URI with additional convenience methods.

79.  final case class RootProject(build: URI) extends ProjectReference with Product with Serializable

    Identifies the root project in the specified build.

80.  class Run extends ScalaRun
81.  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.

82.  sealed trait ScalaRun extends AnyRef
83.  final case class Scope(project: ScopeAxis[Reference], config: ScopeAxis[ConfigKey], task: ScopeAxis[AttributeKey[_]], extra: ScopeAxis[AttributeMap]) extends Product with Serializable
84.  sealed trait ScopeAxis[+S] extends AnyRef
85.  final case class ScopeMask(project: Boolean = true, config: Boolean = true, task: Boolean = true, extra: Boolean = true) extends Product with Serializable

    Specifies the Scope axes that should be used for an operation.

    Specifies the Scope axes that should be used for an operation. true indicates an axis should be used.

86.  sealed trait Scoped extends Equals

    An abstraction on top of Settings for build configuration and task definition.

87.  final case class ScopedKeyData[A](scoped: Def.ScopedKey[A], value: Any) extends Product with Serializable
88.  sealed trait ScopedTaskable[T] extends Scoped with Taskable[T]

    A common type for SettingKey and TaskKey so that both can be used as inputs to tasks.

89.  final class ScriptMain extends AppMain
90.  sealed trait ScriptedRun extends AnyRef
91.  final case class Select[S](s: S) extends ScopeAxis[S] with Product with Serializable

    Select is a type constructor that is used to wrap type S to make a scope component, equivalent of Some in Option.

92.  final case class Selected[A, B](fab: Task[Either[A, B]], fin: Task[(A) ⇒ B]) extends Action[B] with Product with Serializable

    A computation that conditionally falls back to a second transformation.

    A computation that conditionally falls back to a second transformation. This can be used to encode if conditions.

93.  sealed abstract class ServerAuthentication extends Serializable
94.  sealed abstract class SettingKey[T] extends ScopedTaskable[T] with sbt.Def.KeyedInitialize[T] with ScopingSetting[SettingKey[T]] with DefinableSetting[T]

    Identifies a setting.

    Identifies a setting. It consists of three parts: the scope, the name, and the type of a value associated with this key. The scope is represented by a value of type Scope. The name and the type are represented by a value of type AttributeKey[T]. Instances are constructed using the companion object.

95.  trait SlashSyntax extends AnyRef

    SlashSyntax implements the slash syntax to scope keys for build.sbt DSL.

    SlashSyntax implements the slash syntax to scope keys for build.sbt DSL. The implicits are set up such that the order that the scope components must appear in the order of the project axis, the configuration axis, and the task axis. This ordering is the same as the shell syntax.

    Example:

    1. Global / cancelable := true
       ThisBuild / scalaVersion := "2.12.2"
       Test / test := ()
       console / scalacOptions += "-deprecation"
       Compile / console / scalacOptions += "-Ywarn-numeric-widen"
       projA / Compile / console / scalacOptions += "-feature"
       Zero / Zero / name := "foo"

96.  final case class State(configuration: AppConfiguration, definedCommands: Seq[Command], exitHooks: Set[ExitHook], onFailure: Option[Exec], remainingCommands: List[Exec], history: History, attributes: AttributeMap, globalLogging: GlobalLogging, currentCommand: Option[Exec], next: Next) extends Identity with Product with Serializable

    Data structure representing all command execution information.

    Data structure representing all command execution information.

    configuration

    provides access to the launcher environment, including the application configuration, Scala versions, jvm/filesystem wide locking, and the launcher itself

    definedCommands

    the list of command definitions that evaluate command strings. These may be modified to change the available commands.

    exitHooks

    code to run before sbt exits, usually to ensure resources are cleaned up.

    onFailure

    the command to execute when another command fails. onFailure is cleared before the failure handling command is executed.

    remainingCommands

    the sequence of commands to execute. This sequence may be modified to change the commands to be executed. Typically, the :: and ::: methods are used to prepend new commands to run.

    history

    tracks the recently executed commands

    attributes

    custom command state. It is important to clean up attributes when no longer needed to avoid memory leaks and class loader leaks.

    next

    the next action for the command processor to take. This may be to continue with the next command, adjust global logging, or exit.

97.  trait StateOps extends Any

    Convenience methods for State transformations and operations.

98.  final class StateTransform extends AnyRef

    Provides a mechanism for a task to transform the state based on the result of the task.

    Provides a mechanism for a task to transform the state based on the result of the task. For example:

    val foo = AttributeKey[String]("foo")
    val setFoo = taskKey[StateTransform]("")
    setFoo := {
      state.value.get(foo) match {
        case None => StateTransform(_.put(foo, "foo"))
        case _ => StateTransform(identity)
      }
    }
    val getFoo = taskKey[Option[String]]
    getFoo := state.value.get(foo)

    Prior to a call to setFoo, getFoo will return None. After a call to setFoo, getFoo will return Some("foo").

99.  final case class Task[T](info: Info[T], work: Action[T]) extends Product with Serializable

    Combines metadata info and a computation work to define a task.

100.  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.

101.  sealed abstract class TaskKey[T] extends ScopedTaskable[T] with sbt.Def.KeyedInitialize[Task[T]] with ScopingSetting[TaskKey[T]] with DefinableTask[T]

     Identifies a task.

     Identifies a task. It consists of three parts: the scope, the name, and the type of the value computed by a task associated with this key. The scope is represented by a value of type Scope. The name and the type are represented by a value of type AttributeKey[Task[T]]. Instances are constructed using the companion object.

102.  trait TaskMacroExtra extends AnyRef
103.  sealed trait Taskable[T] extends AnyRef

     A SettingKey, TaskKey or Initialize[Task] that can be converted into an Initialize[Task].

104.  sealed trait TaskableImplicits extends AnyRef
105.  case class TemplateResolverInfo(module: ModuleID, implementationClass: String) extends Product with Serializable
106.  trait Terminal extends AnyRef

     A Terminal represents a ui connection to sbt.

     A Terminal represents a ui connection to sbt. It may control the embedded console for an sbt server or it may control a remote client connected through sbtn. The Terminal is particularly useful whenever an sbt task needs to receive input from the user.

107.  sealed trait TestOption extends AnyRef
108.  trait TestResultLogger extends AnyRef

     Logs information about tests after they finish.

     Logs information about tests after they finish.

     Log output can be customised by providing a specialised instance of this trait via the testResultLogger setting.

     Since

     0.13.5

109.  final class TestsFailedException extends RuntimeException with FeedbackProvidedException
110.  final class Triggers[F[_]] extends AnyRef
111.  trait TupleSyntax extends AnyRef

     The sbt 0.10 style DSL was deprecated in 0.13.13, favouring the use of the '.value' macro.

     The sbt 0.10 style DSL was deprecated in 0.13.13, favouring the use of the '.value' macro.

     See https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#Migrating+from+sbt+0.12+style for how to migrate.

112.  trait UpperStateOps extends Any

     Extends State with setting-level knowledge.

113.  final case class Value[+T](value: T) extends Result[T] with Product with Serializable

     Indicates the task completed normally and produced the given value.

114.  class sbtUnchecked extends Annotation

     An annotation to designate that the annotated entity should not be considered for additional sbt compiler checks.

     An annotation to designate that the annotated entity should not be considered for additional sbt compiler checks. These checks ensure that the DSL is predictable and prevents users from doing dangerous things at the cost of a stricter code structure.

     Since

     1.0.0

115.  final class xMain extends AppMain

     This class is the entry point for sbt.

116.  sealed trait Doc extends AnyRef

     Annotations

     @deprecated

     Deprecated

     (Since version 1.1.1) Going away

117.  trait Watched extends AnyRef

     Annotations

     @deprecated

     Deprecated

     (Since version 1.3.0) Watched is no longer used to implement continuous execution