Introduce BuildInfoKey.of/ofN macros

These exist to avoid having to explain the concept of the .taskValue
method and sbt.Task to users.

Author: dwijnand

build.sbt

@@ -12,6 +12,8 @@ lazy val root = (project in file(".")).
     // sbtVersion in Global := "0.13.0" 
     // scalaVersion in Global := "2.10.2"
     scalacOptions := Seq("-unchecked", "-deprecation", "-feature", "-language:implicitConversions"),
+    scalacOptions += "-language:experimental.macros",
+    libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value % Provided,
     description := "sbt plugin to generate build info",
     licenses := Seq("MIT License" -> url("https://github.com/sbt/sbt-buildinfo/blob/master/LICENSE")),
     scriptedLaunchOpts ++= Seq("-Xmx1024M", "-Dplugin.version=" + version.value),

src/main/scala/sbtbuildinfo/package.scala

@@ -15,6 +15,9 @@ package object sbtbuildinfo {
       BuildInfoKey.Mapped(from, fun)
     def action[A: Manifest](name: String)(fun: => A): Entry[A] = Action(name, () => fun)
 
+    def of(x: Any): BuildInfoKey = macro BuildInfoKeyMacros.ofImpl
+    def ofN(xs: Any*): Seq[BuildInfoKey] = macro BuildInfoKeyMacros.ofNImpl
+
     private[sbtbuildinfo] final case class Setting[A](scoped: SettingKey[A]) extends Entry[A] {
       def manifest = scoped.key.manifest
     }
@@ -39,4 +42,33 @@ package object sbtbuildinfo {
       private[sbtbuildinfo] def manifest: Manifest[A]
     }
   }
+
+  import scala.reflect.macros.blackbox
+
+  final class BuildInfoKeyMacros(val c: blackbox.Context) {
+    import c.universe._
+
+    val BuildInfoKey = q"_root_.sbtbuildinfo.BuildInfoKey"
+
+    def ofImpl(x: Tree): Tree = {
+      x.tpe match {
+        case tpe if tpe <:< typeOf[SettingKey[_]] =>
+          val A = tpe.typeArgs.head
+          q"$BuildInfoKey.setting[$A]($x)"
+
+        case tpe if tpe <:< typeOf[TaskKey[_]] =>
+          val A = tpe.typeArgs.head
+          q"$BuildInfoKey.taskValue[$A]($x.taskValue)($x.key.manifest.typeArguments.head.asInstanceOf[Manifest[$A]])"
+
+        case tpe if tpe <:< typeOf[(_, _)] =>
+          val A = tpe.typeArgs.tail.head
+          q"$BuildInfoKey.constant[$A]($x)"
+
+        case tpe if tpe <:< typeOf[BuildInfoKey] => x
+      }
+    }
+
+    def ofNImpl(xs: Tree*): Tree = q"_root_.scala.Seq(..${xs map ofImpl})"
+
+  }
 }

src/sbt-test/sbt-buildinfo/task/build.sbt

@@ -19,7 +19,7 @@ val projInTaskGraph1 = project settings (
 val projInTaskGraph2 = project dependsOn projInTaskGraph1 settings (
   BuildInfoPlugin.buildInfoDefaultSettings,
   addBuildInfoToConfig(Test),
-  buildInfoKeys in Test += (fullClasspath in Compile).taskValue
+  buildInfoKeys in Test += BuildInfoKey.of(fullClasspath in Compile)
 )
 
 TaskKey[Unit]("checkOutOfTaskGraph") := {

src/test/scala/sbtbuildinfo/BuildInfoKeySpec.scala

@@ -0,0 +1,62 @@
+package sbtbuildinfo
+
+import sbt._, Keys._
+import BuildInfoPlugin.autoImport._
+
+object BuildInfoKeySpec {
+  buildInfoKeys  := Seq(name, version)                         // test `:=` works with setting keys
+  buildInfoKeys  := Seq(products, fullClasspath)               // test `:=` works with task keys
+  buildInfoKeys  := Seq(name, fullClasspath)                   // test `:=` works with setting and task keys
+  buildInfoKeys  := Seq(                                       // test `:=` works with misc things
+    name,
+    fullClasspath,
+    "year" -> 2012,
+    BuildInfoKey.action("buildTime") { 1234L },
+    BuildInfoKey.map(version) { case (_, v) => "projectVersion" -> v.toDouble }
+  )
+
+  buildInfoKeys  += name                                       // test `+=` works with a setting key
+  buildInfoKeys  += fullClasspath                              // test `+=` works with a task key
+  buildInfoKeys  += "year" -> 2012                             // test `+=` works with constants
+  buildInfoKeys  += BuildInfoKey.action("buildTime") { 1234L } // test `+=` works with BuildInfoKey's
+  buildInfoKeys  += BuildInfoKey.map(version) { case (_, v) => "projectVersion" -> v.toDouble }
+
+  buildInfoKeys ++= Seq(name, version)                         // test `++=` works with setting keys
+  buildInfoKeys ++= Seq(fullClasspath)                         // test `++=` works with 1 task key
+  buildInfoKeys ++= Seq[BuildInfoKey](products, fullClasspath) // test `++=` works with n task keys
+  buildInfoKeys ++= Seq[BuildInfoKey](name, fullClasspath)     // test `++=` works with setting and task keys
+  buildInfoKeys ++= Seq[BuildInfoKey](                         // test `++=` works with misc things
+    name,
+    fullClasspath,
+    "year" -> 2012,
+    BuildInfoKey.action("buildTime") { 1234L },
+    BuildInfoKey.map(version) { case (_, v) => "projectVersion" -> v.toDouble }
+  )
+
+
+  buildInfoKeys  := BuildInfoKey.ofN(name, version)           // test `:=` works with setting keys
+  buildInfoKeys  := BuildInfoKey.ofN(products, fullClasspath) // test `:=` works with task keys
+  buildInfoKeys  := BuildInfoKey.ofN(name, fullClasspath)     // test `:=` works with setting and task keys
+  buildInfoKeys  := BuildInfoKey.ofN(                         // test `:=` works with misc things
+    name,
+    fullClasspath,
+    "year" -> 2012,
+    BuildInfoKey.action("buildTime") { 1234L },
+    BuildInfoKey.map(version) { case (_, v) => "projectVersion" -> v.toDouble }
+  )
+
+  buildInfoKeys  += BuildInfoKey.of(name)                     // test `+=` works with a setting key
+  buildInfoKeys  += BuildInfoKey.of(fullClasspath)            // test `+=` works with a task key
+
+  buildInfoKeys ++= BuildInfoKey.ofN(name, version)           // test `++=` works with setting keys
+  buildInfoKeys ++= BuildInfoKey.ofN(fullClasspath)           // test `++=` works with 1 task key
+  buildInfoKeys ++= BuildInfoKey.ofN(products, fullClasspath) // test `++=` works with n task keys
+  buildInfoKeys ++= BuildInfoKey.ofN(name, fullClasspath)     // test `++=` works with setting and task keys
+  buildInfoKeys ++= BuildInfoKey.ofN(                         // test `++=` works with misc things
+    name,
+    fullClasspath,
+    "year" -> 2012,
+    BuildInfoKey.action("buildTime") { 1234L },
+    BuildInfoKey.map(version) { case (_, v) => "projectVersion" -> v.toDouble }
+  )
+}