luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
sbt/src/sphinx/Getting-Started/Directories.rst

94 lines
2.5 KiB
ReStructuredText
Raw Normal View History

first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
===================
Directory structure
===================
This page assumes you've :doc:`installed sbt <Setup>` and
seen the :doc:`Hello, World <Hello>` example.
Base directory
--------------
In sbt's terminology, the "base directory" is the directory containing
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 project. So if you created a project `hello` containing
`hello/build.sbt` and `hello/hw.scala` as in the :doc:`Hello, World <Hello>`
example, `hello` is your base directory.
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
Source code
-----------
Source code can be placed in the project's base directory as with
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
`hello/hw.scala`. However, most people don't do this for real
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
projects; too much clutter.
sbt uses the same directory structure as
`Maven <http://maven.apache.org/>`_ for source files by default (all
paths are relative to the base directory):
doc updates, conversions, howto extension, theme from akka
2012-09-19 02:12:32 +02:00
.. code-block:: text
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
src/
main/
resources/
<files to include in main jar here>
scala/
<main Scala sources>
java/
<main Java sources>
test/
resources
<files to include in test jar here>
scala/
<test Scala sources>
java/
<test Java 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
Other directories in `src/` will be ignored. Additionally, all hidden
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
directories will be ignored.
sbt build definition files
--------------------------
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
You've already seen `build.sbt` in the project's base directory. Other
sbt files appear in a `project` subdirectory.
first step in md -> rst conversion
2012-09-15 00:08:35 +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
`project` can contain `.scala` files, which are combined with
`.sbt` files to form the complete build definition.
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
See :doc:`.scala build definitions <Full-Def>` for more.
doc updates, conversions, howto extension, theme from akka
2012-09-19 02:12:32 +02:00
.. code-block:: text
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
build.sbt
project/
Build.scala
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
You may see `.sbt` files inside `project/` but they are not
equivalent to `.sbt` files in the project's base directory. Explaining
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
this will :doc:`come later <Full-Def>`, since you'll need
some background information first.
Build products
--------------
Generated files (compiled classes, packaged jars, managed files, caches,
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
and documentation) will be written to the `target` directory by
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
default.
Configuring version control
---------------------------
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
Your `.gitignore` (or equivalent for other version control systems)
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
should contain:
doc updates, conversions, howto extension, theme from akka
2012-09-19 02:12:32 +02:00
.. code-block:: text
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
target/
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
Note that this deliberately has a trailing `/` (to match only
directories) and it deliberately has no leading `/` (to match
`project/target/` in addition to plain `target/`).
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
Next
====
Learn about :doc:`running sbt <Running>`.