sbt
package
sbt
Type Members
-
type
:+:[H, T <: HList] = HCons[H, T]
-
type
CompileOrder = CompileOrder
-
type
Endo[T] = (T) ⇒ T
-
type
File = File
-
type
FileMap = (File) ⇒ Option[File]
-
type
Id[X] = X
-
type
PathMap = (File) ⇒ Option[String]
-
type
ScopedKey[T] = ScopedKey[T]
-
type
Setting[T] = Setting[T]
-
type
SettingsDefinition = SettingsDefinition
-
type
URI = URI
-
type
URL = URL
-
type
~>|[A[_], B[_]] = ~>[A, [T]Option[B[T]]]
-
type
ScopedInput[T] = InputKey[T]
-
type
ScopedSetting[T] = SettingKey[T]
-
type
ScopedTask[T] = TaskKey[T]
Value Members
-
val
:+:: sbt.HCons.type
-
val
:^:: sbt.KCons.type
-
final
val
Compile: Configuration
-
final
val
Default: Configuration
-
final
val
Docs: Configuration
-
final
val
GlobalScope: Scope
-
final
val
IntegrationTest: Configuration
-
final
val
Optional: Configuration
-
final
val
Provided: Configuration
-
final
val
Runtime: Configuration
-
-
final
val
Sources: Configuration
-
final
val
Test: Configuration
-
final
val
ThisScope: Scope
-
def
abs: (File) ⇒ Option[File]
-
implicit final
def
actionToTask[T](a: Action[T]): Task[T]
-
def
addArtifact(artifact: Initialize[Artifact], taskDef: Initialize[Task[File]]): SettingsDefinition
-
def
addArtifact(a: Artifact, taskDef: TaskKey[File]): SettingsDefinition
-
def
addCommandAlias(name: String, value: String): Seq[Setting[(State) ⇒ State]]
-
def
addCompilerPlugin(dependency: ModuleID): Setting[Seq[ModuleID]]
-
def
addSbtPlugin(dependency: ModuleID): Setting[Seq[ModuleID]]
-
def
addSbtPlugin(dependency: ModuleID, sbtVersion: String): Setting[Seq[ModuleID]]
-
def
addSbtPlugin(dependency: ModuleID, sbtVersion: String, scalaVersion: String): Setting[Seq[ModuleID]]
-
def
allSubpaths(base: File): Traversable[(File, String)]
-
implicit
def
alternative[A, B](f: (A) ⇒ Option[B]): Alternative[A, B]
-
final
def
alternatives[A, B](alts: Seq[(A) ⇒ Option[B]]): (A) ⇒ Option[B]
-
def
artifactFilter(name: NameFilter, type: NameFilter, extension: NameFilter, classifier: NameFilter): ArtifactFilter
-
val
basic: (File) ⇒ Option[String]
-
implicit final
def
binaryPipeTask[Key](in: sbt.Task[_])(implicit streams: Task[TaskStreams[Key]], key: (sbt.Task[_]) ⇒ Key): BinaryPipe
-
implicit
def
builderToProcess(builder: ProcessBuilder): ProcessBuilder
-
implicit
def
buildersToProcess[T](builders: Seq[T])(implicit convert: (T) ⇒ SourcePartialBuilder): Seq[SourcePartialBuilder]
-
implicit
def
classpathDependency[T](p: T)(implicit arg0: (T) ⇒ ProjectReference): ClasspathDependency
-
def
compilerPlugin(dependency: ModuleID): ModuleID
-
def
config(s: String): Configuration
-
implicit
def
configDependencyConstructor[T](p: T)(implicit arg0: (T) ⇒ ProjectReference): Constructor
-
def
configurationFilter(name: NameFilter): ConfigurationFilter
-
final
def
const[A, B](b: B): (A) ⇒ B
-
final
def
constant[T](t: T): Task[T]
-
def
externalIvyFile(file: Initialize[File], iScala: Initialize[Option[IvyScala]]): Setting[Task[ModuleSettings]]
-
def
externalIvySettings(file: Initialize[File], addMultiResolver: Boolean): Setting[Task[IvyConfiguration]]
-
def
externalIvySettingsURI(uri: Initialize[URI], addMultiResolver: Boolean): Setting[Task[IvyConfiguration]]
-
def
externalIvySettingsURL(url: URL, addMultiResolver: Boolean): Setting[Task[IvyConfiguration]]
-
def
externalPom(file: Initialize[File], iScala: Initialize[Option[IvyScala]]): Setting[Task[ModuleSettings]]
-
implicit final
def
f2ToHfun[A, B, R](f: (A, B) ⇒ R): (:+:[A, :+:[B, HNil]]) ⇒ R
-
implicit final
def
f3ToHfun[A, B, C, R](f: (A, B, C) ⇒ R): (:+:[A, :+:[B, :+:[C, HNil]]]) ⇒ R
-
def
fail: (Any) ⇒ Nothing
-
def
file(s: String): File
-
implicit
def
fileToProcess(file: File): FilePartialBuilder
-
implicit
def
filesToFinder(cc: Traversable[File]): PathFinder
-
def
filterKeys(ss: Seq[sbt.Project.Setting[_]], transitive: Boolean)(f: (sbt.Project.ScopedKey[_]) ⇒ Boolean): Seq[sbt.Project.Setting[_]]
-
def
flat(newDirectory: File): (File) ⇒ Option[File]
-
val
flat: (File) ⇒ Option[String]
-
def
flatRebase(newBase: String): (File) ⇒ Option[String]
-
def
fullRunInputTask(scoped: InputKey[Unit], config: Configuration, mainClass: String, baseArguments: String*): Setting[InputTask[Unit]]
-
def
fullRunTask(scoped: TaskKey[Unit], config: Configuration, mainClass: String, arguments: String*): Setting[Task[Unit]]
-
def
getForParser[P, T](task: TaskKey[T])(init: (State, Option[T]) ⇒ Parser[P]): Initialize[(State) ⇒ Parser[P]]
-
def
getForParserI[P, T](task: TaskKey[T])(init: Initialize[(State, Option[T]) ⇒ Parser[P]]): Initialize[(State) ⇒ Parser[P]]
-
def
getFromContext[T](task: TaskKey[T], context: sbt.Project.ScopedKey[_], s: State): Option[T]
-
def
getPrevious[T](task: TaskKey[T]): Initialize[Task[Option[T]]]
-
implicit
def
globFilter(expression: String): NameFilter
-
final
def
idFun[T]: (T) ⇒ T
-
def
idK[M[_]]: ~>[M, M]
-
def
inConfig(conf: Configuration)(ss: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]
-
def
inScope(scope: Scope)(ss: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]
-
def
inTask(t: Scoped)(ss: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]
-
def
initScope[T](s: Scope, i: Initialize[T]): Initialize[T]
-
def
initScoped[T](sk: sbt.Project.ScopedKey[_], i: Initialize[T]): Initialize[T]
-
final
def
inlineTask[T](value: T): Task[T]
-
def
inputTask[T](f: (TaskKey[Seq[String]]) ⇒ Initialize[Task[T]]): Initialize[InputTask[T]]
-
implicit final
def
iterableTask[S](in: Seq[S]): ForkTask[S, Seq]
-
implicit final
def
joinAnyTasks(in: Seq[sbt.Task[_]]): JoinTask[Any, Seq]
-
implicit final
def
joinTasks[S](in: Seq[Task[S]]): JoinTask[S, Seq]
-
final
val
left: ~>[Id, [B]Left[B, Nothing]]
-
implicit final
def
linesTask[Key](in: sbt.Task[_])(implicit streams: Task[TaskStreams[Key]], key: (sbt.Task[_]) ⇒ Key): TaskLines
-
def
loadForParser[P, T](task: TaskKey[T])(f: (State, Option[T]) ⇒ Parser[P])(implicit format: Format[T]): Initialize[(State) ⇒ Parser[P]]
-
def
loadForParserI[P, T](task: TaskKey[T])(init: Initialize[(State, Option[T]) ⇒ Parser[P]])(implicit format: Format[T]): Initialize[(State) ⇒ Parser[P]]
-
def
loadFromContext[T](task: TaskKey[T], context: sbt.Project.ScopedKey[_], s: State)(implicit f: Format[T]): Option[T]
-
def
loadPrevious[T](task: TaskKey[T])(implicit f: Format[T]): Initialize[Task[Option[T]]]
-
implicit
def
maybeToOption[S](m: Maybe[S]): Option[S]
-
def
moduleFilter(organization: NameFilter, name: NameFilter, revision: NameFilter): ModuleFilter
-
implicit final
def
moduleIDConfigurable(m: ModuleID): ModuleIDConfigurable
-
implicit final
def
multInputTask[In <: HList](tasks: Tasks[In]): MultiInTask[In]
-
def
nestCon[M[_], N[_], G[_]](f: ~>[M, N]): ~>[[T]M[G[T]], [T]N[G[T]]]
-
def
noTestCompletion(config: Configuration): sbt.Project.Setting[_]
-
final
def
nop: Task[Unit]
-
def
normalizeBase(base: String): String
-
def
overrideConfigs(cs: Configuration*)(configurations: Seq[Configuration]): Seq[Configuration]
-
implicit final
def
pipeToProcess[Key](t: sbt.Task[_])(implicit streams: Task[TaskStreams[Key]], key: (sbt.Task[_]) ⇒ Key): ProcessPipe
-
implicit
def
processToTask(p: ProcessBuilder)(implicit streams: Task[sbt.std.TaskStreams[_]]): Task[Int]
-
def
rebase(oldBase: File, newBase: File): (File) ⇒ Option[File]
-
def
rebase(oldBases: Iterable[File], newBase: File, zero: (File) ⇒ Option[File]): (File) ⇒ Option[File]
-
def
rebase(oldBase: File, newBase: String): (File) ⇒ Option[String]
-
def
relativeTo(bases: Iterable[File], zero: (File) ⇒ Option[String]): (File) ⇒ Option[String]
-
def
relativeTo(base: File): (File) ⇒ Option[String]
-
def
resolve(newDirectory: File): (File) ⇒ Option[File]
-
implicit
def
richAttributed(s: Seq[Attributed[File]]): RichAttributed
-
implicit
def
richFile(file: File): RichFile
-
implicit
def
richFiles(s: Seq[File]): RichFiles
-
implicit
def
richPathFinder(s: PathFinder): RichPathFinder
-
final
val
right: ~>[Id, [B]Right[Nothing, B]]
-
def
runInputTask(config: Configuration, mainClass: String, baseArguments: String*): Initialize[InputTask[Unit]]
-
def
runTask(config: Configuration, mainClass: String, arguments: String*): Initialize[Task[Unit]]
-
def
selectSubpaths(base: File, filter: FileFilter): Traversable[(File, String)]
-
def
seq(settings: sbt.Project.Setting[_]*): SettingsDefinition
-
implicit
def
singleFileFinder(file: File): PathFinder
-
implicit final
def
singleInputTask[S](in: Task[S]): SingleInTask[S]
-
final
val
some: ~>[Id, Some]
-
implicit
def
stringSeqToProcess(command: Seq[String]): ProcessBuilder
-
implicit
def
stringToProcess(command: String): ProcessBuilder
-
implicit final
def
t2ToMulti[A, B](t: (Task[A], Task[B])): MultiInTask[:+:[A, :+:[B, HNil]]]
-
implicit final
def
t3ToMulti[A, B, C](t: (Task[A], Task[B], Task[C])): MultiInTask[:+:[A, :+:[B, :+:[C, HNil]]]]
-
final
def
task[T](f: ⇒ T): Task[T]
-
implicit final
def
textPipeTask[Key](in: sbt.Task[_])(implicit streams: Task[TaskStreams[Key]], key: (sbt.Task[_]) ⇒ Key): TextPipe
-
def
toError(o: Option[String]): Unit
-
implicit
def
toFn1[A, B](f: (A) ⇒ B): Fn1[A, B]
-
implicit final
def
toGroupID(groupID: String): GroupID
-
implicit final
def
toRepositoryName(name: String): RepositoryName
-
implicit final
def
toTask[T](f: () ⇒ T): Task[T]
-
implicit final
def
toTaskInfo[S](in: Task[S]): TaskInfo[S]
-
implicit final
def
toTasks[S](in: Seq[() ⇒ S]): Seq[Task[S]]
-
def
total[A, B](f: (A) ⇒ B): (A) ⇒ Some[B]
-
def
transparent: (Any) ⇒ Option[Nothing]
-
implicit final
def
upcastTask[A >: B, B](t: Task[B]): Task[A]
-
def
uri(s: String): URI
-
def
url(s: String): URL
-
implicit
def
urlToProcess(url: URL): URLPartialBuilder
-
implicit
def
xmlToProcess(command: Elem): ProcessBuilder
Deprecated Value Members
-
val
CommandSupport: sbt.CommandStrings.type