Packages

p

sbt

package sbt

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

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 = 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.

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

  47. 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.

  48. 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.

  49. final class JavaVersion extends Serializable
  50. abstract class JobHandle extends AnyRef
  51. 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.

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

    Identifies a project in the current build context.

  53. 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.

  54. 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

  55. trait OptionSyntax extends AnyRef
  56. sealed abstract class OutputStrategy extends AnyRef

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

  57. sealed trait PackageOption extends AnyRef
  58. 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
  59. 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.

  60. sealed trait Plugins extends AnyRef

    An expression that matches AutoPlugins.

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

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

  67. sealed trait ProjectReference extends Reference

    Identifies a project.

  68. 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.

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

    Identifies a project or build.

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

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

  74. sealed trait Result[+T] extends AnyRef

    Result of completely evaluating a task.

  75. class RichURI extends AnyRef

    Extends URI with additional convenience methods.

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

    Identifies the root project in the specified build.

  77. class Run extends ScalaRun
  78. 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.

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

  83. sealed trait Scoped extends Equals

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

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

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

  86. final class ScriptMain extends AppMain
  87. 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.

  88. sealed abstract class ServerAuthentication extends Serializable
  89. 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.

  90. 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"
  91. 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.

  92. trait StateOps extends Any

    Convenience methods for State transformations and operations.

  93. final class StateTransform extends AnyRef
  94. 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.

  95. 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.

  96. 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.

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

  101. final class TestsFailedException extends RuntimeException with FeedbackProvidedException
  102. final class Triggers[F[_]] extends AnyRef
  103. 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.

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

    Indicates the task completed normally and produced the given value.

  105. 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

  106. final class xMain extends AppMain

    This class is the entry point for sbt.

  107. sealed trait Doc extends AnyRef
    Annotations
    @deprecated
    Deprecated

    (Since version 1.1.1) Going away

  108. trait Watched extends AnyRef
    Annotations
    @deprecated
    Deprecated

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

Value Members

  1. object Append
  2. object ApplicationID extends Serializable
  3. object AutoPluginException extends Serializable
  4. object BackgroundJobService
  5. object BasicCommandStrings
  6. object BasicCommands
  7. object BasicKeys
  8. object BuildPaths
  9. object BuiltinCommands
  10. object ClassLoaderLayeringStrategy

    Provides instances of ClassLoaderLayeringStrategy that can be used to define the ClassLoader used by Keys.run, Keys.test or any other task that runs java code inside of the sbt jvm.

  11. object Classpaths
  12. object Command
  13. object CommandLineUIService extends InteractionService with CommandLineUIService
  14. object CommandSource extends Serializable
  15. object CommandUtil
  16. object CompletionService
  17. object ConcurrentRestrictions
  18. object ConfigKey extends Serializable
  19. object ConnectionType extends Serializable
  20. object Console
  21. object Cross

    Cross implements the Scala cross building commands: + ("cross") command and ++ ("switch") command.

  22. object Def extends Init[Scope] with TaskMacroExtra

    A concrete settings system that uses sbt.Scope for the scope type.

  23. object DefaultOptions
  24. object Defaults extends BuildCommon
  25. object Doc
  26. object DotGraph
  27. object EvaluateTask
  28. object EvaluateTaskConfig
  29. object Exec extends Serializable
  30. object ExecuteProgress

    This module is experimental and subject to binary and source incompatible changes at any time.

  31. object Fork
  32. object ForkOptions extends Serializable
  33. object Help
  34. object Highlight
  35. object Incomplete extends Enumeration
  36. object Info extends Serializable
  37. object InputKey

    Constructs InputKeys, which are associated with input tasks to define a setting.

  38. object InputTask
  39. object JavaVersion extends Serializable
  40. object KeyRanks
  41. object Keys
  42. object LocalRootProject extends ProjectReference with Product with Serializable

    Identifies the root project in the current build context.

  43. object MainLoop
  44. object OptionSyntax extends OptionSyntax
  45. object Opts

    Options for well-known tasks.

  46. object OutputStrategy
  47. object Package

    This module provides an API to package jar files.

    Package

    This module provides an API to package jar files.

    See also

    https://docs.oracle.com/javase/tutorial/deployment/jar/index.html

  48. object PluginData extends Serializable
  49. object PluginTrigger extends Serializable
  50. object Plugins extends PluginsFunctions
  51. object Previous
  52. object Project extends ProjectExtra
  53. object ProjectOrigin extends Serializable
  54. object ProjectRef extends Serializable
  55. object RawCompileLike
  56. object Reference
  57. object Remove
  58. object Resolvers
  59. object Result
  60. object RichURI
  61. object RootProject extends Serializable
  62. object Run

    This module is an interface to starting the scala interpreter or runner.

  63. object Scope extends Serializable
  64. object ScopeAxis
  65. object ScopeFilter
  66. object Scoped

    Methods and types related to constructing settings, including keys, scopes, and initializations.

  67. object ScriptedPlugin extends AutoPlugin
  68. object SelectMainClass
  69. object ServerAuthentication extends Serializable
  70. object SessionVar
  71. object SettingKey

    Constructs SettingKeys, which are associated with a value to define a basic setting.

  72. object SlashSyntax
  73. object StandardMain
  74. object State extends Serializable
  75. object StateTransform
  76. object Sync

    Maintains a set of mappings so that they are uptodate.

    Maintains a set of mappings so that they are uptodate. Specifically, 'apply' applies the mappings by creating target directories and copying source files to their destination. For each mapping no longer present, the old target is removed. Caution: Existing files are overwritten. Caution: The removal of old targets assumes that nothing else has written to or modified those files. It tries not to obliterate large amounts of data by only removing previously tracked files and empty directories. That is, it won't remove a directory with unknown (untracked) files in it. Warning: It is therefore inappropriate to use this with anything other than an automatically managed destination or a dedicated target directory. Warning: Specifically, don't mix this with a directory containing manually created files, like sources. It is safe to use for its intended purpose: copying resources to a class output directory.

  77. object Tags
  78. object TaskCancellationStrategy
  79. object TaskKey

    Constructs TaskKeys, which are associated with tasks to define a setting.

  80. object TestResultLogger
  81. object Tests
  82. object This extends ScopeAxis[Nothing] with Product with Serializable

    This is a scope component that represents not being scoped by the user, which later could be further scoped automatically by sbt.

  83. object ThisBuild extends BuildReference with Product with Serializable

    Identifies the build for the current context.

  84. object ThisProject extends ProjectReference with Product with Serializable

    Identifies the project for the current context.

  85. object TrapExit

    Provides an approximation to isolated execution within a single JVM.

    Provides an approximation to isolated execution within a single JVM. System.exit calls are trapped to prevent the JVM from terminating. This is useful for executing user code that may call System.exit, but actually exiting is undesirable.

    Exit is simulated by disposing all top-level windows and interrupting user-started threads. Threads are not stopped and shutdown hooks are not called. It is therefore inappropriate to use this with code that requires shutdown hooks, creates threads that do not terminate, or if concurrent AWT applications are run. This category of code should only be called by forking a new JVM.

  86. object TupleSyntax extends TupleSyntax
  87. object Watched
  88. object Zero extends ScopeAxis[Nothing] with Product with Serializable

    Zero is a scope component that represents not scoping.

    Zero is a scope component that represents not scoping. It is a universal fallback component that is strictly weaker than any other values on a scope axis.

Ungrouped