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/Update-Report.rst

196 lines
7.3 KiB
ReStructuredText
Raw Normal View History

first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
=============
Update Report
=============
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
`update` and related tasks produce a value of type
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
`sbt.UpdateReport <../../api/sbt/UpdateReport.html>`_
This data structure provides information about the resolved
configurations, modules, and artifacts. At the top level,
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
`UpdateReport` provides reports of type `ConfigurationReport` for
each resolved configuration. A `ConfigurationReport` supplies reports
(of type `ModuleReport`) for each module resolved for a given
configuration. Finally, a `ModuleReport` lists each successfully
retrieved `Artifact` and the `File` it was retrieved to as well as
the `Artifact`\ s that couldn't be downloaded. This missing
`Arifact` list is always empty for `update`, which will fail if it is
non-empty. However, it may be non-empty for `updateClassifiers` and
`updateSbtClassifers`.
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
Filtering a Report and Getting Artifacts
========================================
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 typical use of `UpdateReport` is to retrieve a list of files
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
matching a filter. A conversion of type
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
`UpdateReport => RichUpdateReport` implicitly provides these methods
for `UpdateReport`. The filters are defined by the
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
`DependencyFilter <../../api/sbt/DependencyFilter.html>`_,
`ConfigurationFilter <../../api/sbt/ConfigurationFilter.html>`_,
`ModuleFilter <../../api/sbt/ModuleFilter.html>`_,
and
`ArtifactFilter <../../api/sbt/ArtifactFilter.html>`_
types. Using these filter types, you can filter by the configuration
name, the module organization, name, or revision, and the artifact name,
type, extension, or classifier.
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 relevant methods (implicitly on `UpdateReport`) are:
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
::
def matching(f: DependencyFilter): Seq[File]
def select(configuration: ConfigurationFilter = ..., module: ModuleFilter = ..., artifact: ArtifactFilter = ...): Seq[File]
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
Any argument to `select` may be omitted, in which case all values are
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
allowed for the corresponding component. For example, if 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
`ConfigurationFilter` is not specified, all configurations are
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
accepted. The individual filter types are discussed below.
Filter Basics
-------------
Configuration, module, and artifact filters are typically built by
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
applying a `NameFilter` to each component of a `Configuration`,
`ModuleID`, or `Artifact`. A basic `NameFilter` is implicitly
constructed from a String, with `*` interpreted as a wildcard.
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
::
import sbt._
// each argument is of type NameFilter
val mf: ModuleFilter = moduleFilter(organization = "*sbt*", name = "main" | "actions", revision = "1.*" - "1.0")
// unspecified arguments match everything by default
val mf: ModuleFilter = moduleFilter(organization = "net.databinder")
// specifying "*" is the same as omitting the argument
val af: ArtifactFilter = artifactFilter(name = "*", `type` = "source", extension = "jar", classifier = "sources")
val cf: ConfigurationFilter = configurationFilter(name = "compile" | "test")
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
Alternatively, these filters, including a `NameFilter`, may be
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
directly defined by an appropriate predicate (a single-argument function
returning a Boolean).
::
import sbt._
// here the function value of type String => Boolean is implicitly converted to a NameFilter
val nf: NameFilter = (s: String) => s.startsWith("dispatch-")
// a Set[String] is a function String => Boolean
val acceptConfigs: Set[String] = Set("compile", "test")
// implicitly converted to a ConfigurationFilter
val cf: ConfigurationFilter = acceptConfigs
val mf: ModuleFilter = (m: ModuleID) => m.organization contains "sbt"
val af: ArtifactFilter = (a: Artifact) => a.classifier.isEmpty
ConfigurationFilter
-------------------
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 configuration filter essentially wraps a `NameFilter` and is
explicitly constructed by the `configurationFilter` method:
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
::
def configurationFilter(name: NameFilter = ...): ConfigurationFilter
If the argument is omitted, the filter matches all configurations.
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
Functions of type `String => Boolean` are implicitly convertible to a
`ConfigurationFilter`. As with `ModuleFilter`, `ArtifactFilter`,
and `NameFilter`, the `&`, `|`, and `-` methods may be used to
combine `ConfigurationFilter`\ s.
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
::
import sbt._
val a: ConfigurationFilter = Set("compile", "test")
val b: ConfigurationFilter = (c: String) => c.startsWith("r")
val c: ConfigurationFilter = a | b
(The explicit types are optional here.)
ModuleFilter
------------
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 module filter is defined by three `NameFilter`\ s: one for the
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
organization, one for the module name, and one for the revision. Each
component filter must match for the whole module filter to match. 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
module filter is explicitly constructed by the `moduleFilter` method:
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
::
def moduleFilter(organization: NameFilter = ..., name: NameFilter = ..., revision: NameFilter = ...): ModuleFilter
An omitted argument does not contribute to the match. If all arguments
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 omitted, the filter matches all `ModuleID`\ s. Functions of type
`ModuleID => Boolean` are implicitly convertible to a
`ModuleFilter`. As with `ConfigurationFilter`, `ArtifactFilter`,
and `NameFilter`, the `&`, `|`, and `-` methods may be used to
combine `ModuleFilter`\ s:
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
::
import sbt._
val a: ModuleFilter = moduleFilter(name = "dispatch-twitter", revision = "0.7.8")
val b: ModuleFilter = moduleFilter(name = "dispatch-*")
val c: ModuleFilter = b - a
(The explicit types are optional here.)
ArtifactFilter
--------------
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
An artifact filter is defined by four `NameFilter`\ s: one for the
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
name, one for the type, one for the extension, and one for the
classifier. Each component filter must match for the whole artifact
filter to match. An artifact filter is explicitly constructed by 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
`artifactFilter` method:
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
::
def artifactFilter(name: NameFilter = ..., `type`: NameFilter = ..., extension: NameFilter = ..., classifier: NameFilter = ...): ArtifactFilter
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
Functions of type `Artifact => Boolean` are implicitly convertible to
an `ArtifactFilter`. As with `ConfigurationFilter`,
`ModuleFilter`, and `NameFilter`, the `&`, `|`, and `-`
methods may be used to combine `ArtifactFilter`\ s:
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
::
import sbt._
val a: ArtifactFilter = artifactFilter(classifier = "javadoc")
val b: ArtifactFilter = artifactFilter(`type` = "jar")
val c: ArtifactFilter = b - a
(The explicit types are optional here.)
DependencyFilter
----------------
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 `DependencyFilter` is typically constructed by combining other
`DependencyFilter`\ s together using `&&`, `||`, and `--`.
Configuration, module, and artifact filters are `DependencyFilter`\ s
themselves and can be used directly as a `DependencyFilter` or they
can build up a `DependencyFilter`. Note that the symbols for the
`DependencyFilter` combining methods are doubled up to distinguish
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
them from the combinators of the more specific filters for
configurations, modules, and artifacts. These double-character methods
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
will always return a `DependencyFilter`, whereas the single character
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
methods preserve the more specific filter type. For example:
::
import sbt._
val df: DependencyFilter =
configurationFilter(name = "compile" | "test") && artifactFilter(`type` = "jar") || moduleFilter(name = "dispatch-*")
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
Here, we used `&&` and `||` to combine individual component filters
first step in md -> rst conversion
2012-09-15 00:08:35 +02:00
into a dependency filter, which can then be provided to 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
`UpdateReport.matches` method. Alternatively, the
`UpdateReport.select` method may be used, which is equivalent to
calling `matches` with its arguments combined with `&&`.