luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
sbt/src/sphinx/Detailed-Topics/Command-Line-Reference.rst

229 lines
14 KiB
ReStructuredText
Raw Normal View History

first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
======================
Command Line Reference
======================
This page is a relatively complete list of command line options,
commands, and tasks you can use from the sbt interactive prompt or in
batch mode. See :doc:`Running </Getting-Started/Running>` in the Getting
Started Guide for an intro to the basics, while this page has a lot more
detail.
Notes on the command line
-------------------------
- There is a technical distinction in sbt between *tasks*, which are
"inside" the build definition, and *commands*, which manipulate the
build definition itself. If you're interested in creating a command,
see :doc:`/Extending/Commands`. This specific sbt meaning of "command" means
there's no good general term for "thing you can type at the sbt
prompt", which may be a setting, task, or command.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- Some tasks produce useful values. The `toString` representation of
these values can be shown using `show <task>` to run the task
instead of just `<task>`.
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
- In a multi-project build, execution dependencies and the
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
`aggregate` setting control which tasks from which projects are
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
executed. See :doc:`multi-project builds </Getting-Started/Multi-Project>`.
Project-level tasks
-------------------
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `clean` Deletes all generated files (the `target` directory).
- `publishLocal` Publishes artifacts (such as jars) to the local Ivy
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
repository as described in :doc:`Publishing`.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `publish` Publishes artifacts (such as jars) to the repository
defined by the `publishTo` setting, described in :doc:`Publishing`.
- `update` Resolves and retrieves external dependencies as described
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
in :doc:`library dependencies </Getting-Started/Library-Dependencies>`.
Configuration-level tasks
-------------------------
Configuration-level tasks are tasks associated with a configuration. For
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
example, `compile`, which is equivalent to `compile:compile`,
compiles the main source code (the `compile` configuration).
`test:compile` compiles the test source code (test `test`
configuration). Most tasks for the `compile` configuration have an
equivalent in the `test` configuration that can be run using a
`test:` prefix.
- `compile` Compiles the main sources (in the `src/main/scala`
directory). `test:compile` compiles test sources (in the
`src/test/scala/` directory).
- `console` Starts the Scala interpreter with a classpath including
the compiled sources, all jars in the `lib` directory, and managed
libraries. To return to sbt, type `:quit`, Ctrl+D (Unix), or Ctrl+Z
(Windows). Similarly, `test:console` starts the interpreter with
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
the test classes and classpath.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `consoleQuick` Starts the Scala interpreter with the project's
compile-time dependencies on the classpath. `test:consoleQuick`
uses the test dependencies. This task differs from `console` in
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
that it does not force compilation of the current project's sources.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `consoleProject` Enters an interactive session with sbt and the
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
build definition on the classpath. The build definition and related
values are bound to variables and common packages and values are
Docs: initial pass for updated task syntax, vals in .sbt, camelCase
2012-11-19 02:29:01 +01:00
imported. See the :doc:`consoleProject documentation <Console-Project>` for more information.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `doc` Generates API documentation for Scala source files in
`src/main/scala` using scaladoc. `test:doc` generates API
documentation for source files in `src/test/scala`.
- `package` Creates a jar file containing the files in
`src/main/resources` and the classes compiled from
`src/main/scala`. `test:package` creates a jar containing the
files in `src/test/resources` and the class compiled from
`src/test/scala`.
- `packageDoc` Creates a jar file containing API documentation
generated from Scala source files in `src/main/scala`.
`test:packageDoc` creates a jar containing API documentation for
test sources files in `src/test/scala`.
- `packageSrc`: Creates a jar file containing all main source files
and resources. The packaged paths are relative to `src/main/scala`
and `src/main/resources`. Similarly, `test:packageSrc` operates
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
on test source files and resources.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `run <argument>*` Runs the main class for the project in the same
virtual machine as `sbt`. The main class is passed the
`argument`\ s provided. Please see :doc:`Running-Project-Code` for
details on the use of `System.exit` and multithreading (including
GUIs) in code run by this action. `test:run` runs a main class in
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
the test code.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `runMain <main-class> <argument>*` Runs the specified main class
for the project in the same virtual machine as `sbt`. The main
class is passed the `argument`\ s provided. Please see :doc:`Running-Project-Code`
for details on the use of `System.exit` and
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
multithreading (including GUIs) in code run by this action.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
`test:runMain` runs the specified main class in the test code.
- `test` Runs all tests detected during test compilation. See
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
:doc:`Testing` for details.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `testOnly <test>*` Runs the tests provided as arguments. `*`
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
(will be) interpreted as a wildcard in the test name. See :doc:`Testing`
for details.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `testQuick <test>*` Runs the tests specified as arguments (or all
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
tests if no arguments are given) that:
1. have not been run yet OR
2. failed the last time they were run OR
3. had any transitive dependencies recompiled since the last
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
successful run `*` (will be) interpreted as a wildcard in the
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
test name. See :doc:`Testing` for details.
General commands
----------------
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `exit` or `quit` End the current interactive session or build.
Additionally, `Ctrl+D` (Unix) or `Ctrl+Z` (Windows) will exit the
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
interactive prompt.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `help <command>` Displays detailed help for the specified command.
If the command does not exist, `help` lists detailed help for
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
commands whose name or description match the argument, which is
interpreted as a regular expression. If no command is provided,
displays brief descriptions of the main commands. Related commands
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
are `tasks` and `settings`.
- `projects [add|remove <URI>]` List all available projects if no
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
arguments provided or adds/removes the build at the provided URI.
(See :doc:`/Getting-Started/Full-Def/` for details on multi-project builds.)
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `project <project-id>` Change the current project to the project
with ID `<project-id>`. Further operations will be done in the
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
context of the given project. (See :doc:`/Getting-Started/Full-Def/` for details
on multiple project builds.)
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `~ <command>` Executes the project specified action or method
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
whenever source files change. See :doc:`/Detailed-Topics/Triggered-Execution` for
details.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `< filename` Executes the commands in the given file. Each command
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
should be on its own line. Empty lines and lines beginning with '#'
are ignored
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `+ <command>` Executes the project specified action or method for
all versions of Scala defined in the `crossScalaVersions`
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
setting.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `++ <version|home-directory> <command>` Temporarily changes the version of Scala
building the project and executes the provided command. `<command>`
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
is optional. The specified version of Scala is used until the project
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
is reloaded, settings are modified (such as by the `set` or
`session` commands), or `++` is run again. `<version>` does not
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
need to be listed in the build definition, but it must be available
Temporarily use a Scala home with '++ /path/to/scala/home'
2013-01-28 23:14:53 +01:00
in a repository. Alternatively, specify the path to a Scala installation.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `; A ; B` Execute A and if it succeeds, run B. Note that the
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
leading semicolon is required.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `eval <Scala-expression>` Evaluates the given Scala expression and
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
returns the result and inferred type. This can be used to set system
properties, as a calculator, to fork processes, etc ... For example:
::
> eval System.setProperty("demo", "true")
> eval 1+1
> eval "ls -l" !
Commands for managing the build definition
------------------------------------------
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `reload [plugins|return]` If no argument is specified, reloads the
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
build, recompiling any build or plugin definitions as necessary.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
`reload plugins` changes the current project to the build
definition project (in `project/`). This can be useful to directly
manipulate the build definition. For example, running `clean` on
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
the build definition project will force snapshots to be updated and
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
the build definition to be recompiled. `reload return` changes back
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
to the main project.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `set <setting-expression>` Evaluates and applies the given setting
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
definition. The setting applies until sbt is restarted, the build is
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
reloaded, or the setting is overridden by another `set` command or
removed by the `session` command. See
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
:doc:`.sbt build definition </Getting-Started/Basic-Def>` and
:doc:`Inspecting-Settings` for details.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `session <command>` Manages session settings defined by the `set`
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
command. It can persist settings configured at the prompt. See
:doc:`Inspecting-Settings` for details.
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
- `inspect <setting-key>` Displays information about settings, such
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
as the value, description, defining scope, dependencies, delegation
chain, and related settings. See :doc:`Inspecting-Settings` for details.
Command Line Options
--------------------
System properties can be provided either as JVM options, or as SBT
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
arguments, in both cases as `-Dprop=value`. The following properties
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
influence SBT execution. Also see :doc:`Launcher`.
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
+------------------------------+-----------+---------------------+----------------------------------------------------+
| Property | Values | Default | Meaning |
+==============================+===========+=====================+====================================================+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.log.noformat` | Boolean | false | If true, disable ANSI color codes. Useful on build |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
| | | | servers or terminals that don't support color. |
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.global.base` | Directory | ~/.sbt | The directory containing global settings and |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
| | | | plugins |
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.ivy.home` | Directory | ~/.ivy2 | The directory containing the local Ivy repository |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
| | | | and artifact cache |
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.boot.directory` | Directory | ~/.sbt/boot | Path to shared boot directory |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.main.class` | String | | |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `xsbt.inc.debug` | Boolean | false | |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.extraClasspath` | Classpath | | A list of classpath entries (jar files or |
Add `sbt.extraClasspath` to command line reference.
2013-06-26 19:17:49 +02:00
| | Entries | | directories) that are added to sbt's classpath. |
| | | | Note that the entries are deliminted by comma, |
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| | | | e.g.: `entry1, entry2,..`. See also |
| | | | `resources` in the :doc:`Launcher` |
Add `sbt.extraClasspath` to command line reference.
2013-06-26 19:17:49 +02:00
| | | | documentation. |
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.version` | Version | 0.11.3 | sbt version to use, usually taken from |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
| | | | project/build.properties |
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.boot.properties` | File | | |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.override.build.repos` | Boolean | false | If true, repositories configured in a build |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
| | | | definition are ignored and the repositories |
| | | | configured for the launcher are used instead. See |
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| | | | `sbt.repository.config` and the :doc:`Launcher` |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
| | | | documentation. |
+------------------------------+-----------+---------------------+----------------------------------------------------+
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| `sbt.repository.config` | File | ~/.sbt/repositories | A file containing the repositories to use for the |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
| | | | launcher. The format is the same as a |
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| | | | `[repositories]` section for a :doc:`Launcher` |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
| | | | configuration file. This setting is typically used |
| | | | in conjuction with setting |
Docs: custom role 'codeliteral' to allow substitutions in inline code The built-in 'literal' role implements ``. It tokenizes the literal string to attempt some particular wrapping behavior. This puts parts of the string in different spans, each with class='pre' and the previous docs.css had a padding for that class. This led to excessive space within the literal string. The custom role does no do this tokenization, but nested inline parsing can result in multiple nodes, repeating the problem. So, the padding for class='pre' is dropped. Ideally, the sequence of nodes would simply be wrapped in an inline element with class='pre' or some other proper solution that avoids having multiple nodes. To avoid wrapping in the middle of a literal, the 'pre' class now has the style `white-space: pre;`. The default role is now 'codeliteral' and the previous uses of the built-in `` are converted to `. Some incorrectly converted code blocks were fixed in the process. Finally, the Global-Settings page is updated with the new location for the global sbt directory. Due to the above changes, this could be done without hardcoding the version.
2013-07-29 13:27:17 +02:00
| | | | `sbt.override.build.repos` to true (see previous |
Convert table in cmd line reference to a real rST table. Previous table was mix of reStructuredText and html produced by automatic conversion tool. The result was rather unreadable and very hard to edit. I converted the table to native reStructuredText's table.
2013-06-26 08:46:15 +02:00
| | | | row and the :doc:`Launcher` documentation). |
+------------------------------+-----------+---------------------+----------------------------------------------------+