Index ===== This is an index of common methods, types, and values you might find in an sbt build definition. For command names, see :doc:`Running `. For available plugins, see :doc:`the plugins list `. Values and Types ---------------- Dependency Management ~~~~~~~~~~~~~~~~~~~~~ - `ModuleID <../api/sbt/ModuleID.html>`_ is the type of a dependency definition. See :doc:`/Detailed-Topics/Library-Management`. - `Artifact <../api/sbt/Artifact.html>`_ represents a single artifact (such as a jar or a pom) to be built and published. See :doc:`/Detailed-Topics/Library-Management` and :doc:`/Detailed-Topics/Artifacts`. - A `Resolver <../api/sbt/Resolver.html>`_ can resolve and retrieve dependencies. Many types of Resolvers can publish dependencies as well. A repository is a closely linked idea that typically refers to the actual location of the dependencies. However, sbt is not very consistent with this terminology and repository and resolver are occasionally used interchangeably. - A [ModuleConfiguration] defines a specific resolver to use for a group of dependencies. - A `Configuration <../api/sbt/Configuration.html>`_ is a useful Ivy construct for grouping dependencies. See :doc:`/Dormant/Configurations`. It is also used for :doc:`scoping settings `. - ``Compile``, ``Test``, ``Runtime``, ``Provided``, and ``Optional`` are predefined :doc:`/Dormant/Configurations`. Settings and Tasks ~~~~~~~~~~~~~~~~~~ - A `Setting <../api/sbt/Init$Setting.html>`_ describes how to initialize a specific setting in the build. It can use the values of other settings or the previous value of the setting being initialized. - A `SettingsDefinition <../api/sbt/Init$SettingsDefinition.html>`_ is the actual type of an expression in a build.sbt. This allows either a single `Setting <../api/sbt/Init$Setting.html>`_ or a sequence of settings (`SettingList <../api/sbt/Init$SettingList.html>`_) to be defined at once. The types in a :doc:`/Getting-Started/Full-Def` always use just a plain `Setting <../api/sbt/Init$Setting.html>`_. - `Initialize <../api/sbt/Init$Initialize.html>`_ describes how to initialize a setting using other settings, but isn't bound to a particular setting yet. Combined with an initialization method and a setting to initialize, it produces a full `Setting <../api/sbt/Init$Setting.html>`_. - `TaskKey <../api/sbt/TaskKey.html>`_, `SettingKey <../api/sbt/SettingKey.html>`_, and `InputKey <../api/sbt/InputKey.html>`_ are keys that represent a task or setting. These are not the actual tasks, but keys that are used to refer to them. They can be scoped to produce `ScopedTask <../api/sbt/ScopedTask.html>`_, `ScopedSetting <../api/sbt/ScopedSetting.html>`_, and `ScopedInput <../api/sbt/ScopedInput.html>`_. These form the base types that provide the Settings methods. - `InputTask <../api/sbt/InputTask.html>`_ parses and tab completes user input, producing a task to run. - `Task <../api/sbt/Task.html>`_ is the type of a task. A task is an action that runs on demand. This is in contrast to a setting, which is run once at project initialization. Process ~~~~~~~ - A `ProcessBuilder <../api/sbt/ProcessBuilder.html>`_ is the type used to define a process. It provides combinators for building up processes from smaller processes. - A `Process <../api/sbt/Process.html>`_ represents the actual forked process. - The `Process companion object <../api/sbt/Process$.html>`_ provides methods for constructing primitive processes. Build Structure ~~~~~~~~~~~~~~~ - `Build <../api/sbt/Build.html>`_ is the trait implemented for a :doc:`full definition `, which defines project relationships and settings. - `Plugin <../api/sbt/Plugin.html>`_ is the trait implemented for sbt :doc:`/Getting-Started/Using-Plugins`. - `Project <../api/sbt/Project.html>`_ is both a trait and a companion object that declares a single module in a build. See :doc:`full definition `. - `Keys <../api/sbt/Keys$.html>`_ is an object that provides all of the built-in keys for settings and tasks. - `State <../api/sbt/State.html>`_ contains the full state for a build. It is mainly used by :doc:`/Extending/Commands` and sometimes :doc:`/Extending/Input-Tasks`. See also :doc:`/Extending/Build-State`. Methods ------- Settings and Tasks ~~~~~~~~~~~~~~~~~~ See the :doc:`Getting Started Guide ` for details. - ``:=``, ``+=``, ``++=``, ``~=`` These construct a `Setting <../api/sbt/Init$Setting.html>`_, which is the fundamental type in the :doc:`settings ` system. - ``value`` This uses the value of another setting or task in the definition of a new setting or task. This method is special (it is a macro) and cannot be used except in the argument of one of the setting definition methods above (``:=``, ...) or in the standalone construction methods ``Def.setting`` and ``Def.task``. See :doc:`more about settings ` for details. - ``in`` specifies the `Scope <../api/sbt/Scope.html>`_ or part of the `Scope <../api/sbt/Scope.html>`_ of a setting being referenced. See :doc:`scopes `. File and IO ~~~~~~~~~~~ See `RichFile <../api/sbt/RichFile.html>`_, `PathFinder <../api/sbt/PathFinder.html>`_, and :doc:`/Detailed-Topics/Paths` for the full documentation. - ``/`` When called on a single File, this is ``new File(x,y)``. For ``Seq[File]``, this is applied for each member of the sequence.. - ``*`` and ``**`` are methods for selecting children (``*``) or descendants (``**``) of a ``File`` or ``Seq[File]`` that match a filter. - ``|``, ``||``, ``&&``, ``&``, ``-``, and ``--`` are methods for combining filters, which are often used for selecting ``File``\ s. See `NameFilter <../api/sbt/NameFilter.html>`_ and `FileFilter <../api/sbt/FileFilter.html>`_. Note that methods with these names also exist for other types, such as collections (like \`Seq) and `Parser <../api/sbt/complete/Parser.html>`_ (see :doc:`/Detailed-Topics/Parsing-Input`). - ``x`` Used to construct mappings from a ``File`` to another ``File`` or to a ``String``. See :doc:`/Detailed-Topics/Mapping-Files`. - ``get`` forces a `PathFinder <../api/sbt/PathFinder.html>`_ (a call-by-name data structure) to a strict ``Seq[File]`` representation. This is a common name in Scala, used by types like ``Option``. Dependency Management ~~~~~~~~~~~~~~~~~~~~~ See :doc:`/Detailed-Topics/Library-Management` for full documentation. - ``%`` This is used to build up a `ModuleID <../api/sbt/ModuleID.html>`_. - ``%%`` This is similar to ``%`` except that it identifies a dependency that has been :doc:`cross built `. - ``from`` Used to specify the fallback URL for a dependency - ``classifier`` Used to specify the classifier for a dependency. - ``at`` Used to define a Maven-style resolver. - ``intransitive`` Marks a `dependency <../api/sbt/ModuleID.html>`_ or `Configuration <../api/sbt/Configuration.html>`_ as being intransitive. - ``hide`` Marks a `Configuration <../api/sbt/Configuration.html>`_ as internal and not to be included in the published metadata. Parsing ~~~~~~~ These methods are used to build up `Parser <../api/sbt/complete/Parser.html>`_\ s from smaller `Parser <../api/sbt/complete/Parser.html>`_\ s. They closely follow the names of the standard library's parser combinators. See :doc:`/Detailed-Topics/Parsing-Input` for the full documentation. These are used for :doc:`/Extending/Input-Tasks` and :doc:`/Extending/Commands`. - ``~``, ``~>``, ``<~`` Sequencing methods. - ``??``, ``?`` Methods for making a Parser optional. ``?`` is postfix. - ``id`` Used for turning a Char or String literal into a Parser. It is generally used to trigger an implicit conversion to a Parser. - ``|``, ``||`` Choice methods. These are common method names in Scala. - ``^^^`` Produces a constant value when a Parser matches. - ``+``, ``*`` Postfix repetition methods. These are common method names in Scala. - ``map``, ``flatMap`` Transforms the result of a Parser. These are common method names in Scala. - ``filter`` Restricts the inputs that a Parser matches on. This is a common method name in Scala. - ``-`` Prefix negation. Only matches the input when the original parser doesn't match the input. - ``examples``, ``token`` Tab completion - ``!!!`` Provides an error message to use when the original parser doesn't match the input. Processes ~~~~~~~~~ These methods are used to :doc:`fork external processes `. Note that this API has been included in the Scala standard library for version 2.9. `ProcessBuilder <../api/sbt/ProcessBuilder.html>`_ is the builder type and `Process <../api/sbt/Process.html>`_ is the type representing the actual forked process. The methods to combine processes start with ``#`` so that they share the same precedence. - ``run``, ``!``, ``!!``, ``!<``, ``lines``, ``lines_!`` are different ways to start a process once it has been defined. The ``lines`` variants produce a ``Stream[String]`` to obtain the output lines. - ``#<``, ``#<<``, ``#>`` are used to get input for a process from a source or send the output of a process to a sink. - ``#|`` is used to pipe output from one process into the input of another. - ``#||``, ``#&&``, ``###`` sequence processes in different ways.