luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removing plugins and focusing on launcher script.

This commit is contained in:
Josh Suereth 2012-01-16 15:24:19 -05:00
parent d8908cc393
commit 31780795bc
6 changed files with 9 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
README.md
View File

@ -1,4 +1,4 @@
sbt: the rebel cut
sbt: the launcher
==================
An alternative script for running [sbt](https://github.com/harrah/xsbt).
@ -80,39 +80,13 @@ Current -help output:
In the case of duplicated or conflicting options, the order above
shows precedence: JAVA_OPTS lowest, command line options highest.
## SBT Extra plugin
To see the plugin in action, including the thrilling custom sbt command "help-names":
## Native Packages ##
cd template-project && ../sbt -sbt-rc help-names zomg zomg2
The template files are:
This project also includes native packages to run SBT for
* Windows
* RedHat (rpm)
* Debian (deb)
project/plugins/project/Build.scala # you can use this as-is if you want
project/Build.scala # this is a starting point for your real Build.scala
Locations for download to be available soon.
The Template build isn't quite finished. There will most likely be a build.sbt DSL variant that does not require a project scala file.
## Simple SBT DSL
SBT extras defines a simplified task DSL for those who are defining simple tasks that do not need to be relied upon, or you are unsure and can refactor later. Once including the sbt-extra-plugin, all you have to do is place the following in your build.sbt to create tasks:
simple_task("zomg") is { println("ZOMG") }
or if you need to depend on other keys:
simple_task("zomg2") on (name, version) is { (n,v) => println("ZOMG " + n + " = " + v + " !!!!!") }
The DSL currently supports between 0 and 9 dependencies. The DSL does not allow defining tasks on different configurations, although this will be added shortly.
### Simple Setttings
SBT distinguishes between defining Setting and Tasks through the `apply` and `map` methods. The Simple DSL has no such distinction. Defining a setting is as easy as:
simple_setting("name") is "project-name"
Settings can also depend on other settings.
simple_setting("name") on (version) is { v => "project-name" + v }
Since a Setting can *only* be defined using other settings, attempting to use a non-setting in the on calls results in a type error.

4
build.sbt
View File

@ -1,8 +1,8 @@
sbtPlugin := true
name := "sbt-extras-plugin"
name := "sbt-launcher-package"
organization := "org.improving"
organization := "org.scalasbt"
version := "0.1.0"

124
src/main/scala/Main.scala
View File

@ -1,124 +0,0 @@
package template
import sbt._
import Keys._
import Load.{ BuildStructure, StructureIndex }
import scala.collection.{ mutable, immutable }
object SbtExtrasPlugin extends Plugin {
def simple_task(name: String) = sbt.extra.dsl.SimpleTasks.task(name)
def simple_setting(name: String) = sbt.extra.dsl.SimpleTasks.setting(name)
}
trait SbtCreateConfig {
def name: String
def organization: String
def version: String
def scalaVersion: String
}
object SbtCreateConfig {
private def prop(propName: String, alt: String) = System.getProperty(propName) match {
case null => alt
case value => value
}
implicit def defaultProjectConfig = new SbtCreateConfig {
def name = prop("sbt-create.name", "project-name-here")
def organization = prop("sbt-create.organization", "your.organization.here")
def version = prop("sbt-create.version", "0.1-SNAPSHOT")
def scalaVersion = prop("sbt.scala.version", "2.9.0-1")
}
}
class TemplateBuild(implicit sbtCreateConfig: SbtCreateConfig) extends Build {
// BuildStructure contains:
// units: Map[URI, LoadedBuildUnit]
// root: URI
// settings: Seq[Setting[_]]
// data: Settings[Scope]
// index: StructureIndex
// streams: Streams
// delegates: Scope => Seq[Scope]
// scopeLocal: ScopeLocal
private val cachedExtraction = new collection.mutable.HashMap[State, WState]
private implicit def stateWrapper(state: State): WState =
cachedExtraction.getOrElseUpdate(state, new WState(state))
private implicit def revealStructure(state: State): BuildStructure =
stateWrapper(state).structure
private implicit def revealStructureIndex(state: State): StructureIndex =
revealStructure(state).index
private implicit def revealSession(state: State): SessionSettings =
stateWrapper(state).session
private class WState(state: State) {
val extracted = Project extract state
def projectId = extracted.currentProject.id
def structure = extracted.structure
def session = extracted.session
def currentRef = extracted.currentRef
def rootProject = structure.rootProject
def allProjects = structure.allProjects
def index = structure.index
def taskToKey = index.taskToKey
def keyMap = index.keyMap // Map[String, AttributeKey[_]]
def keyIndex = index.keyIndex
def currentKeys = keyIndex keys Some(currentRef) map index.keyMap
def sortedKeys = currentKeys.toSeq sortBy (_.label)
}
private class Tap[T](target: T) {
def show(): Unit = target match {
case xs: TraversableOnce[_] => xs foreach println
case _ => println(target)
}
def tap[U](f: T => U): T = {
f(target)
target
}
}
private implicit def createTapper[T](target: T): Tap[T] = new Tap(target)
def currentBranch = ("git status -sb".lines_! headOption) getOrElse "-" stripPrefix "## "
val buildShellPrompt = {
(state: State) => "%s:%s> ".format(
state.projectId,
currentBranch
)
}
lazy val testSettings = Seq(
libraryDependencies ++= Seq(
"org.scala-tools.testing" % "specs_2.9.0-1" % "1.6.8" % "test"
),
libraryDependencies <+= (scalaVersion)(v => "org.scala-lang" % "scala-compiler" % v)
)
lazy val buildSettings = Seq(
resolvers += ScalaToolsSnapshots,
organization := sbtCreateConfig.organization,
version := sbtCreateConfig.version,
scalaVersion := sbtCreateConfig.scalaVersion,
// retrieveManaged := true,
shellPrompt := buildShellPrompt
// logLevel := Level.Debug,
)
lazy val templateConfig = Project(
id = sbtCreateConfig.name,
base = file("."),
aggregate = Nil,
dependencies = Nil,
delegates = Nil,
settings = Defaults.defaultSettings ++ buildSettings ++ testSettings ++ Seq(
commands += helpNames
)
)
// A sample command definition.
def helpNames = Command.command("help-names") { (state: State) =>
state tap (_.sortedKeys map (_.label) show)
}
}

10
src/main/scala/SimpleDsl.scala
View File

@ -1,10 +0,0 @@
package sbt.extra.dsl
import sbt._
import Scoped._
import Project.{richInitializeTask,richInitialize}
object SimpleTasks {
final def task(name: String) = new TaskId(name)
final def setting(name: String) = new SettingId(name)
}

169
src/main/scala/SimpleSetting.scala
View File

@ -1,169 +0,0 @@
package sbt.extra.dsl
import sbt._
import Scoped._
import Project._
import Project.Setting
/** Represents the new 'id' of a setting to define on a project. */
final class SettingId(name: String) {
/** Creates a Task that has no dependencies. */
final def is[R: Manifest](f: => R) =
SettingKey[R](name) := f
final def on[A1](a: Initialize[A1]): SettingDepend1[A1] =
new SettingDepend1[A1](name, a)
final def on[A1, A2](a1: Initialize[A1], a2: Initialize[A2]): SettingDepend2[A1, A2] =
new SettingDepend2[A1, A2](name, a1, a2)
final def on[A1, A2, A3](a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3]) =
new SettingDepend3[A1, A2, A3](name, a1, a2, a3)
final def on[A1, A2, A3, A4](a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4]) =
new SettingDepend4[A1, A2, A3, A4](name, a1, a2, a3, a4)
final def on[A1, A2, A3, A4, A5](a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5]) =
new SettingDepend5[A1, A2, A3, A4, A5](name, a1, a2, a3, a4, a5)
final def on[A1, A2, A3, A4, A5, A6](a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5],
a6: Initialize[A6]) =
new SettingDepend6[A1, A2, A3, A4, A5, A6](name, a1, a2, a3, a4, a5, a6)
final def on[A1, A2, A3, A4, A5, A6, A7](a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5],
a6: Initialize[A6],
a7: Initialize[A7]) =
new SettingDepend7[A1, A2, A3, A4, A5, A6, A7](name, a1, a2, a3, a4, a5, a6, a7)
final def on[A1, A2, A3, A4, A5, A6, A7, A8](a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5],
a6: Initialize[A6],
a7: Initialize[A7],
a8: Initialize[A8]) =
new SettingDepend8[A1, A2, A3, A4, A5, A6, A7, A8](name, a1, a2, a3, a4, a5, a6, a7, a8)
final def on[A1, A2, A3, A4, A5, A6, A7, A8, A9](a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5],
a6: Initialize[A6],
a7: Initialize[A7],
a8: Initialize[A8],
a9: Initialize[A9]) =
new SettingDepend9[A1, A2, A3, A4, A5, A6, A7, A8, A9](name, a1, a2, a3, a4, a5, a6, a7, a8, a9)
}
/** Represents a not-yet-defined Setting that has one dependency */
final class SettingDepend1[A1](name: String, a1: Initialize[A1]) {
final def is[R: Manifest](f: A1 => R): Setting[R] = {
SettingKey[R](name) <<= a1 apply f
}
}
/** Represents a not-yet-defined Setting that has two dependencies */
final class SettingDepend2[A1, A2](name: String,
a1: Initialize[A1],
a2: Initialize[A2]) {
final def is[R: Manifest](f: (A1, A2) => R): Setting[R] = {
SettingKey[R](name) <<= (a1, a2) apply f
}
}
/** Represents a not-yet-defined Setting that has two dependencies */
final class SettingDepend3[A1, A2, A3](name: String,
a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3]) {
final def is[R: Manifest](f: (A1, A2, A3) => R): Setting[R] = {
SettingKey[R](name) <<= (a1, a2, a3) apply f
}
}
/** Represents a not-yet-defined Setting that has two dependencies */
final class SettingDepend4[A1, A2, A3, A4](name: String,
a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4]) {
final def is[R: Manifest](f: (A1, A2, A3, A4) => R): Setting[R] = {
SettingKey[R](name) <<= (a1, a2, a3, a4) apply f
}
}
/** Represents a not-yet-defined Setting that has two dependencies */
final class SettingDepend5[A1, A2, A3, A4, A5](name: String,
a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5) => R): Setting[R] = {
SettingKey[R](name) <<= (a1, a2, a3, a4, a5) apply f
}
}
/** Represents a not-yet-defined Setting that has two dependencies */
final class SettingDepend6[A1, A2, A3, A4, A5, A6](name: String,
a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5],
a6: Initialize[A6]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5, A6) => R): Setting[R] = {
SettingKey[R](name) <<= (a1, a2, a3, a4, a5, a6) apply f
}
}
/** Represents a not-yet-defined Setting that has two dependencies */
final class SettingDepend7[A1, A2, A3, A4, A5, A6, A7](name: String,
a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5],
a6: Initialize[A6],
a7: Initialize[A7]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5, A6, A7) => R): Setting[R] = {
SettingKey[R](name) <<= (a1, a2, a3, a4, a5, a6, a7) apply f
}
}
/** Represents a not-yet-defined Setting that has two dependencies */
final class SettingDepend8[A1, A2, A3, A4, A5, A6, A7, A8](name: String,
a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5],
a6: Initialize[A6],
a7: Initialize[A7],
a8: Initialize[A8]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5, A6, A7, A8) => R): Setting[R] = {
SettingKey[R](name) <<= (a1, a2, a3, a4, a5, a6, a7, a8) apply f
}
}
/** Represents a not-yet-defined Setting that has two dependencies */
final class SettingDepend9[A1, A2, A3, A4, A5, A6, A7, A8, A9](name: String,
a1: Initialize[A1],
a2: Initialize[A2],
a3: Initialize[A3],
a4: Initialize[A4],
a5: Initialize[A5],
a6: Initialize[A6],
a7: Initialize[A7],
a8: Initialize[A8],
a9: Initialize[A9]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9) => R): Setting[R] = {
SettingKey[R](name) <<= (a1, a2, a3, a4, a5, a6, a7, a8, a9) apply f
}
}

176
src/main/scala/SimpleTask.scala
View File

@ -1,176 +0,0 @@
package sbt.extra.dsl
import sbt._
import Scoped._
import Project._
import Project.Setting
/** Represents the new 'id' of a task to define on a project. */
final class TaskId(name: String) {
/** Creates a Task that has no dependencies. */
final def is[R: Manifest](f: => R) =
TaskKey[R](name) := f
final def on[A1](a: Initialize[Task[A1]]): TaskDepend1Task[A1] =
new TaskDepend1Task[A1](name, a)
final def on[A1](a: Initialize[A1]): TaskDepend1Setting[A1] =
new TaskDepend1Setting[A1](name, a)
final def on[A1, A2](a1: ScopedTaskable[A1], a2: ScopedTaskable[A2]): TaskDepend2[A1, A2] =
new TaskDepend2[A1, A2](name, a1, a2)
final def on[A1, A2, A3](a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3]) =
new TaskDepend3[A1, A2, A3](name, a1, a2, a3)
final def on[A1, A2, A3, A4](a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4]) =
new TaskDepend4[A1, A2, A3, A4](name, a1, a2, a3, a4)
final def on[A1, A2, A3, A4, A5](a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5]) =
new TaskDepend5[A1, A2, A3, A4, A5](name, a1, a2, a3, a4, a5)
final def on[A1, A2, A3, A4, A5, A6](a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5],
a6: ScopedTaskable[A6]) =
new TaskDepend6[A1, A2, A3, A4, A5, A6](name, a1, a2, a3, a4, a5, a6)
final def on[A1, A2, A3, A4, A5, A6, A7](a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5],
a6: ScopedTaskable[A6],
a7: ScopedTaskable[A7]) =
new TaskDepend7[A1, A2, A3, A4, A5, A6, A7](name, a1, a2, a3, a4, a5, a6, a7)
final def on[A1, A2, A3, A4, A5, A6, A7, A8](a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5],
a6: ScopedTaskable[A6],
a7: ScopedTaskable[A7],
a8: ScopedTaskable[A8]) =
new TaskDepend8[A1, A2, A3, A4, A5, A6, A7, A8](name, a1, a2, a3, a4, a5, a6, a7, a8)
final def on[A1, A2, A3, A4, A5, A6, A7, A8, A9](a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5],
a6: ScopedTaskable[A6],
a7: ScopedTaskable[A7],
a8: ScopedTaskable[A8],
a9: ScopedTaskable[A9]) =
new TaskDepend9[A1, A2, A3, A4, A5, A6, A7, A8, A9](name, a1, a2, a3, a4, a5, a6, a7, a8, a9)
}
final class TaskDepend1Setting[A1](name: String, a1: Initialize[A1]) {
final def is[R: Manifest](f: A1 => R): Setting[Task[R]] = {
TaskKey[R](name) <<= a1 map f
}
}
/** Represents a not-yet-defined task that has one dependency */
final class TaskDepend1Task[A1](name: String, a1: Initialize[Task[A1]]) {
final def is[R: Manifest](f: A1 => R): Setting[Task[R]] = {
TaskKey[R](name) <<= a1 map f
}
}
/** Represents a not-yet-defined task that has two dependencies */
final class TaskDepend2[A1, A2](name: String,
a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2]) {
final def is[R: Manifest](f: (A1, A2) => R): Setting[Task[R]] = {
TaskKey[R](name) <<= (a1, a2) map f
}
}
/** Represents a not-yet-defined task that has two dependencies */
final class TaskDepend3[A1, A2, A3](name: String,
a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3]) {
final def is[R: Manifest](f: (A1, A2, A3) => R): Setting[Task[R]] = {
TaskKey[R](name) <<= (a1, a2, a3) map f
}
}
/** Represents a not-yet-defined task that has two dependencies */
final class TaskDepend4[A1, A2, A3, A4](name: String,
a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4]) {
final def is[R: Manifest](f: (A1, A2, A3, A4) => R): Setting[Task[R]] = {
TaskKey[R](name) <<= (a1, a2, a3, a4) map f
}
}
/** Represents a not-yet-defined task that has two dependencies */
final class TaskDepend5[A1, A2, A3, A4, A5](name: String,
a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5) => R): Setting[Task[R]] = {
TaskKey[R](name) <<= (a1, a2, a3, a4, a5) map f
}
}
/** Represents a not-yet-defined task that has two dependencies */
final class TaskDepend6[A1, A2, A3, A4, A5, A6](name: String,
a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5],
a6: ScopedTaskable[A6]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5, A6) => R): Setting[Task[R]] = {
TaskKey[R](name) <<= (a1, a2, a3, a4, a5, a6) map f
}
}
/** Represents a not-yet-defined task that has two dependencies */
final class TaskDepend7[A1, A2, A3, A4, A5, A6, A7](name: String,
a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5],
a6: ScopedTaskable[A6],
a7: ScopedTaskable[A7]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5, A6, A7) => R): Setting[Task[R]] = {
TaskKey[R](name) <<= (a1, a2, a3, a4, a5, a6, a7) map f
}
}
/** Represents a not-yet-defined task that has two dependencies */
final class TaskDepend8[A1, A2, A3, A4, A5, A6, A7, A8](name: String,
a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5],
a6: ScopedTaskable[A6],
a7: ScopedTaskable[A7],
a8: ScopedTaskable[A8]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5, A6, A7, A8) => R): Setting[Task[R]] = {
TaskKey[R](name) <<= (a1, a2, a3, a4, a5, a6, a7, a8) map f
}
}
/** Represents a not-yet-defined task that has two dependencies */
final class TaskDepend9[A1, A2, A3, A4, A5, A6, A7, A8, A9](name: String,
a1: ScopedTaskable[A1],
a2: ScopedTaskable[A2],
a3: ScopedTaskable[A3],
a4: ScopedTaskable[A4],
a5: ScopedTaskable[A5],
a6: ScopedTaskable[A6],
a7: ScopedTaskable[A7],
a8: ScopedTaskable[A8],
a9: ScopedTaskable[A9]) {
final def is[R: Manifest](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9) => R): Setting[Task[R]] = {
TaskKey[R](name) <<= (a1, a2, a3, a4, a5, a6, a7, a8, a9) map f
}
}