sbt
package
sbt
Type Members
-
type
:+:[H, T <: HList] = HCons[H, T]
-
-
sealed
trait
Compose[A[_], B[_]] extends AnyRef
-
sealed
trait
Const[A] extends AnyRef
-
sealed
trait
ConstK[A] extends AnyRef
-
type
Endo[T] = (T) ⇒ T
-
type
File = java.io.File
-
type
FileMap = (java.io.File) ⇒ Option[java.io.File]
-
type
Id[X] = X
-
sealed
trait
P1of2[M[_, _], A] extends AnyRef
-
type
PathMap = (java.io.File) ⇒ Option[String]
-
final
class
RichAttributed extends AnyRef
-
final
class
RichFiles extends AnyRef
-
final
class
RichPathFinder extends AnyRef
-
type
ScopeFilter = Base[Scope]
-
type
ScopedKey[T] = sbt.Def.ScopedKey[T]
-
type
Setting[T] = sbt.Def.Setting[T]
-
type
SettingsDefinition = sbt.Def.SettingsDefinition
-
type
URI = java.net.URI
-
type
URL = java.net.URL
-
type
~>|[A[_], B[_]] = ~>[A, [T]Option[B[T]]]
-
sealed
trait
∙[A[_], B[_]] extends AnyRef
Value Members
-
val
:+:: HCons.type
-
val
:^:: KCons.type
-
-
-
-
final
val
GlobalScope: Scope
-
final
val
IntegrationTest: Configuration
-
-
-
-
-
-
final
val
ThisScope: Scope
-
def
abs: FileMap
-
def
addArtifact(artifact: sbt.Def.Initialize[Artifact], taskDef: sbt.Def.Initialize[Task[java.io.File]]): sbt.Def.SettingsDefinition
-
def
addArtifact(a: Artifact, taskDef: TaskKey[java.io.File]): sbt.Def.SettingsDefinition
-
def
addCommandAlias(name: String, value: String): Seq[sbt.Def.Setting[(State) ⇒ State]]
-
def
addCompilerPlugin(dependency: ModuleID): sbt.Def.Setting[Seq[ModuleID]]
-
def
addMavenResolverPlugin: sbt.Def.Setting[Seq[ModuleID]]
-
def
addSbtPlugin(dependency: ModuleID): sbt.Def.Setting[Seq[ModuleID]]
-
def
addSbtPlugin(dependency: ModuleID, sbtVersion: String): sbt.Def.Setting[Seq[ModuleID]]
-
def
addSbtPlugin(dependency: ModuleID, sbtVersion: String, scalaVersion: String): sbt.Def.Setting[Seq[ModuleID]]
-
def
allSubpaths(base: java.io.File): Traversable[(java.io.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]
-
-
val
basic: PathMap
-
implicit final
def
binaryPipeTask[Key](in: Task[_])(implicit streams: Task[TaskStreams[Key]], key: (Task[_]) ⇒ Key): BinaryPipe
-
implicit
def
builderToProcess(builder: java.lang.ProcessBuilder): ProcessBuilder
-
implicit
def
buildersToProcess[T](builders: Seq[T])(implicit convert: (T) ⇒ SourcePartialBuilder): Seq[SourcePartialBuilder]
-
-
def
compilerPlugin(dependency: ModuleID): ModuleID
-
-
implicit
def
configDependencyConstructor[T](p: T)(implicit arg0: (T) ⇒ ProjectReference): Constructor
-
-
final
def
const[A, B](b: B): (A) ⇒ B
-
final
def
constant[T](t: T): Task[T]
-
def
externalIvyFile(file: sbt.Def.Initialize[java.io.File], iScala: sbt.Def.Initialize[Option[IvyScala]]): sbt.Def.Setting[Task[ModuleSettings]]
-
def
externalIvySettings(file: sbt.Def.Initialize[java.io.File], addMultiResolver: Boolean): sbt.Def.Setting[Task[IvyConfiguration]]
-
def
externalIvySettingsURI(uri: sbt.Def.Initialize[java.net.URI], addMultiResolver: Boolean): sbt.Def.Setting[Task[IvyConfiguration]]
-
def
externalIvySettingsURL(url: java.net.URL, addMultiResolver: Boolean): sbt.Def.Setting[Task[IvyConfiguration]]
-
def
externalPom(file: sbt.Def.Initialize[java.io.File], iScala: sbt.Def.Initialize[Option[IvyScala]]): sbt.Def.Setting[Task[ModuleSettings]]
-
-
def
file(s: String): File
-
implicit
def
fileToProcess(file: java.io.File): FilePartialBuilder
-
implicit
def
filesToFinder(cc: Traversable[java.io.File]): PathFinder
-
def
filterKeys(ss: Seq[sbt.Def.Setting[_]], transitive: Boolean)(f: (sbt.Def.ScopedKey[_]) ⇒ Boolean): Seq[sbt.Def.Setting[_]]
-
def
flat(newDirectory: java.io.File): FileMap
-
val
flat: PathMap
-
def
flatRebase(newBase: String): PathMap
-
def
fullRunInputTask(scoped: InputKey[Unit], config: Configuration, mainClass: String, baseArguments: String*): sbt.Def.Setting[InputTask[Unit]]
-
def
fullRunTask(scoped: TaskKey[Unit], config: Configuration, mainClass: String, arguments: String*): sbt.Def.Setting[Task[Unit]]
-
def
getForParser[P, T](task: TaskKey[T])(init: (State, Option[T]) ⇒ Parser[P]): sbt.Def.Initialize[(State) ⇒ Parser[P]]
-
def
getForParserI[P, T](task: TaskKey[T])(init: sbt.Def.Initialize[(State, Option[T]) ⇒ Parser[P]]): sbt.Def.Initialize[(State) ⇒ Parser[P]]
-
def
getFromContext[T](task: TaskKey[T], context: sbt.Def.ScopedKey[_], s: State): Option[T]
-
def
getPrevious[T](task: TaskKey[T]): sbt.Def.Initialize[Task[Option[T]]]
-
implicit
def
globFilter(expression: String): NameFilter
-
final
def
idFun[T]: (T) ⇒ T
-
final
def
idK[M[_]]: ~>[M, M]
-
def
inAggregates(ref: ProjectReference, transitive: Boolean, includeRoot: Boolean): ProjectFilter
-
def
inAnyConfiguration: sbt.ScopeFilter.ConfigurationFilter
-
def
inAnyProject: ProjectFilter
-
def
inAnyTask: TaskFilter
-
def
inConfig(conf: Configuration)(ss: Seq[sbt.Def.Setting[_]]): Seq[sbt.Def.Setting[_]]
-
def
inConfigurations(configs: Configuration*): sbt.ScopeFilter.ConfigurationFilter
-
def
inDependencies(ref: ProjectReference, transitive: Boolean, includeRoot: Boolean): ProjectFilter
-
def
inGlobalConfiguration: sbt.ScopeFilter.ConfigurationFilter
-
def
inGlobalProject: ProjectFilter
-
def
inGlobalTask: TaskFilter
-
def
inProjects(projects: ProjectReference*): ProjectFilter
-
def
inScope(scope: Scope)(ss: Seq[sbt.Def.Setting[_]]): Seq[sbt.Def.Setting[_]]
-
def
inTask(t: Scoped)(ss: Seq[sbt.Def.Setting[_]]): Seq[sbt.Def.Setting[_]]
-
def
inTasks(tasks: Scoped*): TaskFilter
-
def
inThisBuild(ss: Seq[sbt.Def.Setting[_]]): Seq[sbt.Def.Setting[_]]
-
def
initScope[T](s: Scope, i: sbt.Def.Initialize[T]): sbt.Def.Initialize[T]
-
def
initScoped[T](sk: sbt.Def.ScopedKey[_], i: sbt.Def.Initialize[T]): sbt.Def.Initialize[T]
-
final
def
inlineTask[T](value: T): Task[T]
-
macro
def
inputKey[T](description: String): InputKey[T]
-
implicit final
def
iterableTask[S](in: Seq[S]): ForkTask[S, Seq]
-
implicit final
def
joinAnyTasks(in: Seq[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: Task[_])(implicit streams: Task[TaskStreams[Key]], key: (Task[_]) ⇒ Key): TaskLines
-
def
loadForParser[P, T](task: TaskKey[T])(f: (State, Option[T]) ⇒ Parser[P])(implicit format: Format[T]): sbt.Def.Initialize[(State) ⇒ Parser[P]]
-
def
loadForParserI[P, T](task: TaskKey[T])(init: sbt.Def.Initialize[(State, Option[T]) ⇒ Parser[P]])(implicit format: Format[T]): sbt.Def.Initialize[(State) ⇒ Parser[P]]
-
def
loadFromContext[T](task: TaskKey[T], context: sbt.Def.ScopedKey[_], s: State)(implicit f: Format[T]): Option[T]
-
def
loadPrevious[T](task: TaskKey[T])(implicit f: Format[T]): sbt.Def.Initialize[Task[Option[T]]]
-
implicit
def
macroValueIn[T](in: InputTask[T]): InputEvaluated[T]
-
implicit
def
macroValueT[T](in: Task[T]): MacroValue[T]
-
implicit
def
maybeToOption[S](m: Maybe[S]): Option[S]
-
-
-
implicit final
def
multInputTask[K[L[X]]](tasks: K[Task])(implicit a: AList[K]): MultiInTask[K]
-
implicit final
def
multT2Task[A, B](in: (Task[A], Task[B])): MultiInTask[[L[x]](L[A], L[B])]
-
def
nestCon[M[_], N[_], G[_]](f: ~>[M, N]): ~>[[T]M[G[T]], [T]N[G[T]]]
-
def
noTestCompletion(config: Configuration): sbt.Def.Setting[_]
-
final
def
nop: Task[Unit]
-
def
normalizeBase(base: String): String
-
-
implicit
def
parserToInput[T](in: Parser[T]): ParserInput[T]
-
implicit final
def
pipeToProcess[Key](t: Task[_])(implicit streams: Task[TaskStreams[Key]], key: (Task[_]) ⇒ Key): ProcessPipe
-
-
macro
def
project: Project
-
def
rebase(oldBase: java.io.File, newBase: java.io.File): FileMap
-
def
rebase(oldBases: Iterable[java.io.File], newBase: java.io.File, zero: FileMap): FileMap
-
def
rebase(oldBase: java.io.File, newBase: String): PathMap
-
def
relativeTo(bases: Iterable[java.io.File], zero: PathMap): PathMap
-
def
relativeTo(base: java.io.File): PathMap
-
def
resolve(newDirectory: java.io.File): FileMap
-
implicit
def
richAttributed(s: Seq[Attributed[java.io.File]]): RichAttributed
-
implicit
def
richFile(file: java.io.File): RichFile
-
implicit
def
richFiles(s: Seq[java.io.File]): RichFiles
-
implicit
def
richInitialize[T](i: sbt.Def.Initialize[T]): RichInitialize[T]
-
implicit
def
richInitializeInputTask[T](init: sbt.Def.Initialize[InputTask[T]]): RichInitializeInputTask[T]
-
implicit
def
richInitializeTask[T](init: sbt.Def.Initialize[Task[T]]): RichInitializeTask[T]
-
implicit
def
richPathFinder(s: PathFinder): RichPathFinder
-
implicit
def
richTaskSessionVar[T](init: sbt.Def.Initialize[Task[T]]): RichTaskSessionVar[T]
-
final
val
right: ~>[Id, [B]Right[Nothing, B]]
-
def
runInputTask(config: Configuration, mainClass: String, baseArguments: String*): sbt.Def.Initialize[InputTask[Unit]]
-
def
runTask(config: Configuration, mainClass: String, arguments: String*): sbt.Def.Initialize[Task[Unit]]
-
def
selectSubpaths(base: java.io.File, filter: FileFilter): Traversable[(java.io.File, String)]
-
macro
def
settingKey[T](description: String): SettingKey[T]
-
implicit
def
settingKeyAll[T](key: sbt.Def.Initialize[T]): SettingKeyAll[T]
-
implicit
def
singleFileFinder(file: java.io.File): PathFinder
-
implicit final
def
singleInputTask[S](in: Task[S]): SingleInTask[S]
-
final
val
some: ~>[Id, Some]
-
implicit
def
stateParserToInput[T](in: (State) ⇒ Parser[T]): ParserInput[T]
-
implicit
def
stringSeqToProcess(command: Seq[String]): ProcessBuilder
-
implicit
def
stringToProcess(command: String): ProcessBuilder
-
final
def
task[T](f: ⇒ T): Task[T]
-
macro
def
taskKey[T](description: String): TaskKey[T]
-
implicit
def
taskKeyAll[T](key: sbt.Def.Initialize[Task[T]]): TaskKeyAll[T]
-
implicit final
def
textPipeTask[Key](in: Task[_])(implicit streams: Task[TaskStreams[Key]], key: (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
def
toTaskSequential(d: Def.type): TaskSequential
-
implicit final
def
toTasks[S](in: Seq[() ⇒ S]): Seq[Task[S]]
-
def
total[A, B](f: (A) ⇒ B): (A) ⇒ Some[B]
-
-
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: java.net.URL): URLPartialBuilder
Deprecated Value Members
-
def
inputTask[T](f: (TaskKey[Seq[String]]) ⇒ sbt.Def.Initialize[Task[T]]): sbt.Def.Initialize[InputTask[T]]
-
def
seq(settings: sbt.Def.Setting[_]*): sbt.Def.SettingsDefinition
-
implicit
def
xmlToProcess(command: Elem): ProcessBuilder