sbt
package
sbt
Type Members
-
type
:+:
[H, T <: HList]
= HCons[H, T]
-
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
-
val
Compile
: Configuration
-
val
Default
: Configuration
-
val
Docs
: Configuration
-
val
GlobalScope
: Scope
-
object
Graph
extends AnyRef
-
val
IntegrationTest
: Configuration
-
val
Optional
: Configuration
-
val
Provided
: Configuration
-
val
Runtime
: Configuration
-
val
Sources
: Configuration
-
val
Test
: Configuration
-
val
ThisScope
: Scope
-
def
abs
: FileMap
-
implicit 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
addCompilerPlugin
(dependency: ModuleID): Setting[Seq[ModuleID]]
-
def
addSbtPlugin
(dependency: ModuleID): Setting[Seq[ModuleID]]
-
implicit def
alternative
[A, B]
(f: (A) ⇒ Option[B]): Alternative[A, B]
-
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
: PathMap
-
implicit 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
-
def
const
[A, B]
(b: B): (A) ⇒ B
-
def
constant
[T]
(t: T): Task[T]
-
def
externalIvyFile
(file: Initialize[File], iScala: Initialize[Option[IvyScala]]): Setting[Task[ModuleSettings]]
-
def
externalIvySettings
(file: Initialize[File]): Setting[Task[IvyConfiguration]]
-
def
externalPom
(file: Initialize[File], iScala: Initialize[Option[IvyScala]]): Setting[Task[ModuleSettings]]
-
implicit def
f2ToHfun
[A, B, R]
(f: (A, B) ⇒ R): ($colon$plus$colon[A, $colon$plus$colon[B, HNil]]) ⇒ R
-
implicit def
f3ToHfun
[A, B, C, R]
(f: (A, B, C) ⇒ R): ($colon$plus$colon[A, $colon$plus$colon[B, $colon$plus$colon[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): FileMap
-
val
flat
: PathMap
-
def
flatRebase
(newBase0: String): PathMap
-
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
-
def
idFun
[T]
: (T) ⇒ T
-
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]
-
def
inputTask
[T]
(f: (TaskKey[Seq[String]]) ⇒ Initialize[Task[T]]): Initialize[InputTask[T]]
-
implicit def
iterableTask
[S]
(in: Seq[S]): ForkTask[S, Seq]
-
implicit def
joinAnyTasks
(in: Seq[sbt.Task[_]]): JoinTask[Any, Seq]
-
implicit def
joinTasks
[S]
(in: Seq[Task[S]]): JoinTask[S, Seq]
-
val
left
: ~>[Id, [B]Left[B, Nothing]]
-
implicit 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 def
moduleIDConfigurable
(m: ModuleID): ModuleIDConfigurable
-
implicit 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[_]
-
def
nop
: Task[Unit]
-
def
normalizeBase
(base: String): String
-
def
overrideConfigs
(cs: Configuration*)(configurations: Seq[Configuration]): Seq[Configuration]
-
implicit 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): FileMap
-
def
rebase
(oldBases: Iterable[File], newBase: File, zero: FileMap): FileMap
-
def
rebase
(oldBase: File, newBase0: String): PathMap
-
def
relativeTo
(bases: Iterable[File], zero: PathMap): PathMap
-
def
relativeTo
(base: File): PathMap
-
def
resolve
(newDirectory: File): FileMap
-
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
-
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
seq
(settings: sbt.Project.Setting[_]*): SettingsDefinition
-
implicit def
singleFileFinder
(file: File): PathFinder
-
implicit def
singleInputTask
[S]
(in: Task[S]): SingleInTask[S]
-
val
some
: ~>[Id, Some]
-
implicit def
stringSeqToProcess
(command: Seq[String]): ProcessBuilder
-
implicit def
stringToProcess
(command: String): ProcessBuilder
-
implicit def
t2ToMulti
[A, B]
(t: (Task[A], Task[B])): MultiInTask[$colon$plus$colon[A, $colon$plus$colon[B, HNil]]]
-
implicit def
t3ToMulti
[A, B, C]
(t: (Task[A], Task[B], Task[C])): MultiInTask[$colon$plus$colon[A, $colon$plus$colon[B, $colon$plus$colon[C, HNil]]]]
-
def
task
[T]
(f: ⇒ T): Task[T]
-
implicit 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 def
toGroupID
(groupID: String): GroupID
-
implicit def
toRepositoryName
(name: String): RepositoryName
-
implicit def
toTask
[T]
(f: () ⇒ T): Task[T]
-
implicit def
toTaskInfo
[S]
(in: Task[S]): TaskInfo[S]
-
implicit 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 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