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 ClasspathDep[PR <: ProjectReference] extends AnyRef
11.  final case class ClasspathDependency(project: ProjectReference, configuration: Option[String]) extends ClasspathDep[ProjectReference] with Product with Serializable
12.  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.

13.  trait CommandDefinitions extends (State) ⇒ State
14.  trait CommandLineUIService extends InteractionService
15.  final class CommandSource extends Serializable
16.  sealed trait Completed extends AnyRef
17.  trait CompletionService[A, R] extends AnyRef
18.  trait CompositeProject extends AnyRef
19.  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

20.  final case class ConfigKey(name: String) extends Product with Serializable
21.  sealed abstract class ConnectionType extends Serializable
22.  final class Console extends AnyRef
23.  final class ConsoleMain extends AppMain
24.  trait DefExtra extends AnyRef
25.  sealed trait DelegateIndex extends AnyRef
26.  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.

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

28.  final class Exec extends Serializable
29.  final case class Exit(code: Int) extends xsbti.Exit with Product with Serializable
30.  final case class Extracted(structure: BuildStructure, session: SessionSettings, currentRef: ProjectRef)(implicit showKey: Show[Def.ScopedKey[_]]) extends Product with Serializable
31.  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.

32.  final class Fork extends AnyRef

    Represents a command that can be forked.

33.  final class ForkConfiguration extends Serializable
34.  final class ForkMain extends AnyRef
35.  final class ForkOptions extends Serializable

    Configures forking.

36.  class ForkRun extends ScalaRun
37.  sealed abstract final class ForkTags extends Enum[ForkTags]
38.  trait Help extends AnyRef
39.  trait Identity extends AnyRef
40.  trait Import extends AnyRef
41.  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.

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

43.  final case class Info[T](attributes: AttributeMap = AttributeMap.empty, post: (T) ⇒ AttributeMap = const(AttributeMap.empty)) 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.

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

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

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

47.  final class JavaVersion extends Serializable
48.  abstract class JobHandle extends AnyRef
49.  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.

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

    Identifies a project in the current build context.

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

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

53.  trait OptionSyntax extends AnyRef
54.  sealed abstract class OutputStrategy extends AnyRef

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

55.  sealed trait PackageOption extends AnyRef
56.  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
57.  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.

58.  sealed trait Plugins extends AnyRef

    An expression that matches AutoPlugins.

59.  sealed trait PluginsFunctions extends AnyRef
60.  sealed trait Project extends ProjectDefinition[ProjectReference] with CompositeProject
61.  sealed trait ProjectDefinition[PR <: ProjectReference] extends AnyRef
62.  trait ProjectExtra extends AnyRef
63.  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(".").

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

65.  sealed trait ProjectReference extends Reference

    Identifies a project.

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

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

    Identifies a project or build.

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

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

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

    Result of completely evaluating a task.

73.  class RichURI extends AnyRef

    Extends URI with additional convenience methods.

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

    Identifies the root project in the specified build.

75.  class Run extends ScalaRun
76.  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.

77.  sealed trait ScalaRun extends AnyRef
78.  final case class Scope(project: ScopeAxis[Reference], config: ScopeAxis[ConfigKey], task: ScopeAxis[AttributeKey[_]], extra: ScopeAxis[AttributeMap]) extends Product with Serializable
79.  sealed trait ScopeAxis[+S] extends AnyRef
80.  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.

81.  sealed trait Scoped extends Equals

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

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

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

84.  final class ScriptMain extends AppMain
85.  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.

86.  sealed abstract class ServerAuthentication extends Serializable
87.  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.

88.  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"

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

90.  trait StateOps extends AnyRef

    Convenience methods for State transformations and operations.

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

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

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

94.  trait TaskMacroExtra extends AnyRef
95.  case class TemplateResolverInfo(module: ModuleID, implementationClass: String) extends Product with Serializable
96.  sealed trait TestOption extends AnyRef
97.  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

98.  final class TestsFailedException extends RuntimeException with FeedbackProvidedException
99.  final class Triggers[A[_]] extends AnyRef
100.  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 http://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#Migrating+from+sbt+0.12+style for how to migrate.

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

     Indicates the task completed normally and produced the given value.

102.  trait Watched extends AnyRef
103.  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

104.  final class xMain extends AppMain

     This class is the entry point for sbt.

105.  sealed trait Doc extends AnyRef

     Annotations

     @deprecated

     Deprecated

     (Since version 1.1.1) Going away