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

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

  25. sealed trait Doc extends AnyRef
  26. 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.

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

  31. final class Fork extends AnyRef

    Represents a command that can be forked.

  32. final class ForkConfiguration extends Serializable
  33. final class ForkMain extends AnyRef
  34. final class ForkOptions extends Serializable

    Configures forking.

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

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

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

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

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

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

  46. abstract class JobHandle extends AnyRef
  47. 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.

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

    Identifies a project in the current build context.

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

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

  51. trait OptionSyntax extends AnyRef
  52. sealed abstract class OutputStrategy extends AnyRef

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

  53. sealed trait PackageOption extends AnyRef
  54. 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
  55. 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.

  56. sealed trait Plugins extends AnyRef

    An expression that matches AutoPlugins.

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

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

  63. sealed trait ProjectReference extends Reference

    Identifies a project.

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

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

    Identifies a project or build.

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

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

  70. sealed trait Result [+T] extends AnyRef

    Result of completely evaluating a task.

  71. class RichURI extends AnyRef

    Extends URI with additional convenience methods.

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

    Identifies the root project in the specified build.

  73. class Run extends ScalaRun
  74. 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.

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

  79. sealed trait Scoped extends AnyRef

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

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

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

  82. final class ScriptMain extends AppMain
  83. 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.

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

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

  86. trait StateOps extends AnyRef

    Convenience methods for State transformations and operations.

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

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

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

  90. trait TaskMacroExtra extends AnyRef
  91. case class TemplateResolverInfo (module: ModuleID, implementationClass: String) extends Product with Serializable
  92. sealed trait TestOption extends AnyRef
  93. 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

  94. final class TestsFailedException extends RuntimeException with FeedbackProvidedException
  95. final class Triggers [A[_]] extends AnyRef
  96. 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/0.13/docs/Migrating-from-sbt-012x.html for how to migrate.

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

    Indicates the task completed normally and produced the given value.

  98. trait Watched extends AnyRef
  99. 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

  100. final class xMain extends AppMain

    This class is the entry point for sbt.

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 Classpaths
  11. object Command
  12. object CommandLineUIService extends InteractionService with CommandLineUIService
  13. object CommandSource extends Serializable
  14. object CommandUtil
  15. object CompletionService
  16. object ConcurrentRestrictions
  17. object ConfigKey extends Serializable
  18. object Console
  19. object Cross
  20. object Def extends Init[Scope] with TaskMacroExtra

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

  21. object DefaultOptions
  22. object Defaults extends BuildCommon
  23. object Doc
  24. object DotGraph
  25. object EvaluateTask
  26. object EvaluateTaskConfig
  27. object Exec extends Serializable
  28. object Fork
  29. object ForkOptions extends Serializable
  30. object Help
  31. object Highlight
  32. object Incomplete extends Enumeration
  33. object Info extends Serializable
  34. object InputKey

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

  35. object InputTask
  36. object KeyRanks
  37. object Keys
  38. object LocalRootProject extends ProjectReference with Product with Serializable

    Identifies the root project in the current build context.

  39. object MainLoop
  40. object OptionSyntax extends OptionSyntax
  41. object Opts

    Options for well-known tasks.

  42. object OutputStrategy
  43. object Package
  44. object PluginData extends Serializable
  45. object PluginTrigger extends Serializable
  46. object Plugins extends PluginsFunctions
  47. object Previous
  48. object Project extends ProjectExtra
  49. object ProjectOrigin extends Serializable
  50. object ProjectRef extends Serializable
  51. object RawCompileLike
  52. object Reference
  53. object Remove
  54. object Resolvers
  55. object Result
  56. object RichURI
  57. object RootProject extends Serializable
  58. object Run

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

  59. object Scope extends Serializable
  60. object ScopeAxis
  61. object ScopeFilter
  62. object Scoped

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

  63. object SelectMainClass
  64. object SessionVar
  65. object SettingKey

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

  66. object StandardMain
  67. object State extends Serializable
  68. 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.

  69. object Tags
  70. object TaskCancellationStrategy
  71. object TaskKey

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

  72. object TestResultLogger
  73. object Tests
  74. 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.

  75. object ThisBuild extends BuildReference with Product with Serializable

    Identifies the build for the current context.

  76. object ThisProject extends ProjectReference with Product with Serializable

    Identifies the project for the current context.

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

  78. object TupleSyntax extends TupleSyntax
  79. object Watched
  80. 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