From d72d8808cbdff15abebb10543df32ca1b63c01fc Mon Sep 17 00:00:00 2001 From: Josh Suereth Date: Wed, 14 Sep 2011 14:16:02 -0400 Subject: [PATCH] Simple task DSL for those of us who are lazy --- README.md | 20 +++- src/main/scala/Main.scala | 4 +- src/main/scala/SimpleTask.scala | 172 ++++++++++++++++++++++++++++++++ 3 files changed, 193 insertions(+), 3 deletions(-) create mode 100644 src/main/scala/SimpleTask.scala diff --git a/README.md b/README.md index e1075d3fd..f0de17362 100644 --- a/README.md +++ b/README.md @@ -100,7 +100,7 @@ Current -help output: shows precedence: JAVA_OPTS lowest, command line options highest. -## Template project +# SBT Extra plugin To gain access to the awesome, simply add the following /project/plugins/project/Build.scala file: @@ -111,6 +111,9 @@ To gain access to the awesome, simply add the following /project/plugin lazy val extras = uri("git://github.com/jsuereth/sbt-extras") } + +## Template project + Now to continue the amazement, simply extend the TemplateBuild trait in your project. For example, in your /project/Build.scala file add: @@ -119,4 +122,17 @@ Now to continue the amazement, simply extend the TemplateBuild trait in your pro object MyAwesomeBuild extends TemplateBuild {} -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. + +There will most likely be a variant that can be used solely from build.sbt. + +## Simple task 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 2 and 9 dependencies. The DSL does not allow defining tasks on different configurations, although this will be added shortly. diff --git a/src/main/scala/Main.scala b/src/main/scala/Main.scala index 7727601c7..22c649b04 100644 --- a/src/main/scala/Main.scala +++ b/src/main/scala/Main.scala @@ -5,7 +5,9 @@ import Keys._ import Load.{ BuildStructure, StructureIndex } import scala.collection.{ mutable, immutable } -object SbtExtrasPlugin extends Plugin {} +object SbtExtrasPlugin extends Plugin { + def simple_task(name: String) = sbt.extra.dsl.SimpleTasks.task(name) +} trait SbtCreateConfig { def name: String diff --git a/src/main/scala/SimpleTask.scala b/src/main/scala/SimpleTask.scala new file mode 100644 index 000000000..ea05eaf18 --- /dev/null +++ b/src/main/scala/SimpleTask.scala @@ -0,0 +1,172 @@ +package sbt.extra.dsl + +import sbt._ +import Scoped._ +import Project.{richInitializeTask,richInitialize} + +object SimpleTasks { + final def task(name: String) = new TaskId(name) +} + +/** 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: ScopedTaskable[A1]): TaskDepend1[A1] = + new TaskDepend1[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) +} + +/** Represents a not-yet-defined task that has one dependency */ +/*final class TaskDepend1[A1](name: String, a1: ScopedTaskable[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 + } +} + + +