Project restucturing to support both a plugin that executes cucumber and tight integration into the sbt test phase.

  - separated the project into two parts: plugin and integration
  - started a skeleton implementation of the test integration framework
  - added the ability for the plugin to add test integration to a project by including an alternative set of features
  - created a new test project to test the tight integration to the test phase
  - upped all the version numbers to 0.7.0

Author: skipoleschris

Diff for: .ensime

@@ -82,7 +82,7 @@ To install the cucumber plugin, add entries to the build plugins file (project/p
 
     resolvers += "Templemore Repository" at "http://templemore.co.uk/repo"
 
-    addSbtPlugin("templemore" % "xsbt-cucumber-plugin" % "0.6.2")
+    addSbtPlugin("templemore" % "xsbt-cucumber-plugin" % "0.7.0")
 
 ### Basic Configuration ###
 To add the cucumber plugin settings to a basic project, just add the following to the build.sbt file:
@@ -148,6 +148,10 @@ Requests for features can be posted to the issues list or emailed to the author.
 
 ## Release History ##
 
+### 0.7.0 ###
+
+TODO
+
 ### 0.6.2 ###
 Upgrade to cucumber-jvm version 1.1.1 to allow compatibility with Scala 2.10.0-RC1 release.
 

Diff for: README.markdown

@@ -0,0 +1,38 @@
+package templemore.sbt.cucumber
+
+import org.scalatools.testing._
+
+/**
+ * Framework implementation that allows cucumber to be run as part of sbt's
+ * standard 'test' phase.
+ *
+ * @author Chris Turner
+ */
+class CucumberFramework extends Framework {
+  val name = "cucumber"
+  val tests = Array[Fingerprint](CucumberRunOnceFingerprint) 
+
+  def testRunner(testClassLoader: ClassLoader, loggers: Array[Logger]) = {
+    //TODO
+    println("%%% Creating a new runner...")
+    new CucumberRunner()
+  }
+}
+
+class CucumberRunner extends Runner2 {
+  def run(testClassName: String, fingerprint: Fingerprint, eventHandler: EventHandler, args: Array[String]) = {
+    println("%%% CUCUMBER RUNNER")
+    println("%%% Running test class: " + testClassName)
+    println("%%%  with fingerprint: " + fingerprint)
+    println("%%%  with eventHandler: " + eventHandler)
+    println("%%%  with args: " + args.mkString(", "))
+    //TODO
+  }  
+}
+
+object CucumberRunOnceFingerprint extends SubclassFingerprint {
+  val isModule = false
+  val superClassName = classOf[RunCucumber].getName
+}  
+
+trait RunCucumber

Diff for: build.sbt

@@ -1,23 +1,25 @@
-package templemore.xsbt.cucumber
+package templemore.sbt.cucumber
 
 import sbt._
 import Keys._
 import Project.Initialize
+import templemore.sbt.util._
 
 /**
  * @author Chris Turner
  */
-object CucumberPlugin extends Plugin with CucumberIntegration {
+object CucumberPlugin extends Plugin with Integration {
 
+  private val projectVersion = "0.7.0"
   private val CucumberVersionForScala2_9 = "1.0.9"
   private val CucumberVersionForScala2_10 = "1.1.1"
 
   type LifecycleCallback = () => Unit
 
   val cucumber = InputKey[Int]("cucumber")
-  val cucumberTestSettings = TaskKey[CucumberSettings]("cucumber-settings")
-  val cucumberOptions = TaskKey[CucumberOptions]("cucumber-options")
-  val cucumberOutput = TaskKey[CucumberOutput]("cucumber-output")
+  val cucumberTestSettings = TaskKey[JvmSettings]("cucumber-settings")
+  val cucumberOptions = TaskKey[Options]("cucumber-options")
+  val cucumberOutput = TaskKey[Output]("cucumber-output")
 
   val cucumberMaxMemory = SettingKey[String]("cucumber-max-memory")
   val cucumberMaxPermGen = SettingKey[String]("cucumber-max-perm-gen")
@@ -43,28 +45,22 @@ object CucumberPlugin extends Plugin with CucumberIntegration {
   val cucumberAfter = SettingKey[LifecycleCallback]("cucumber-after")
 
   protected def cucumberTask(argTask: TaskKey[Seq[String]]) =
-    (argTask, cucumberTestSettings, cucumberOptions, cucumberOutput, streams) map(testWithCucumber)
+    (argTask, cucumberTestSettings, cucumberOptions, cucumberOutput, streams) map(cuke)
 
-  protected def cucumberSettingsTask: Initialize[Task[CucumberSettings]] =
-    (cucumberMaxMemory, cucumberMaxPermGen, cucumberSystemProperties, cucumberJVMOptions, fullClasspath in Test, streams) map {
-      (mm, mpg, sp, jvmopt, cp, s) => {
-        CucumberSettings(mm, mpg, sp, jvmopt, cp.toList.map(_.data), LoggedOutput(s.log))
-      }
+  protected def cucumberSettingsTask: Initialize[Task[JvmSettings]] =
+    (fullClasspath in Test, cucumberMainClass, streams, cucumberSystemProperties, cucumberJVMOptions, cucumberMaxMemory, cucumberMaxPermGen) map {
+      (cp, mc, s, sp, jvmopt, mm, mpg) => JvmSettings(cp.toList.map(_.data), mc, LoggedOutput(s.log), sp, jvmopt, Some(mm), Some(mpg))
     }
 
-  protected def cucumberOptionsTask: Initialize[Task[CucumberOptions]] =
-    (cucumberMainClass, cucumberFeaturesDir, cucumberStepsBasePackage, cucumberExtraOptions,
-     cucumberBefore, cucumberAfter) map {
-      (mc, fd, bp, o, bf, af) => {
-        CucumberOptions(mc, fd, bp, o, bf, af)
-      }
-    }
+  protected def cucumberOptionsTask: Initialize[Task[Options]] =
+    (cucumberFeaturesDir, cucumberStepsBasePackage, cucumberExtraOptions,
+     cucumberBefore, cucumberAfter) map ((fd, bp, o, bf, af) => Options(fd, bp, o, bf, af))
 
-  protected def cucumberOutputTask: Initialize[Task[CucumberOutput]] =
+  protected def cucumberOutputTask: Initialize[Task[Output]] =
     (cucumberPrettyReport, cucumberHtmlReport, cucumberJunitReport, cucumberJsonReport,
      cucumberPrettyReportFile, cucumberHtmlReportDir, cucumberJunitReportFile, cucumberJsonReportFile) map {
       (pR, hR, juR, jsR, pRF, hRD, juRF, jsRF) => {
-        CucumberOutput(pR, hR, juR, jsR, pRF, hRD, juRF, jsRF)
+        Output(pR, hR, juR, jsR, pRF, hRD, juRF, jsRF)
       }
     }
 
@@ -77,7 +73,7 @@ object CucumberPlugin extends Plugin with CucumberIntegration {
   private def cucumberMain(scalaVersion: String) = 
     if ( scalaVersion.startsWith("2.10") ) "cucumber.api.cli.Main" else "cucumber.cli.Main"
 
-  val cucumberSettings = Seq(
+  val cucumberSettings: Seq[Setting[_]] = Seq(
     libraryDependencies <+= scalaVersion { sv =>
       "info.cukes" % "cucumber-scala" % cucumberVersion(sv) % "test"      
     },
@@ -110,4 +106,11 @@ object CucumberPlugin extends Plugin with CucumberIntegration {
     cucumberBefore := defaultBefore,
     cucumberAfter := defaultAfter
   )
-}
+
+  val cucumberSettingsWithTestPhaseIntegration = cucumberSettings ++ Seq(
+    libraryDependencies ++= Seq(
+      "templemore" %% "sbt-cucumber-integration" % projectVersion % "test"
+    ),
+    testFrameworks += new TestFramework("templemore.sbt.cucumber.CucumberFramework")
+  ) 
+}

Diff for: integration/src/main/scala/templemore/sbt/cucumber/CucumberFramework.scala

@@ -0,0 +1,68 @@
+package templemore.sbt.cucumber
+
+import sbt._
+import std.TaskStreams
+import templemore.sbt.util._
+
+/**
+ * Provides the actual integration with cucumber jvm. Capable of launching 
+ * cucumber as both a forked JVM and within the current JVM process.
+ *
+ * @author Chris Turner
+ */
+trait Integration {
+
+  protected def cuke(args: Seq[String],
+                     jvmSettings: JvmSettings,
+                     options: Options,
+                     output: Output,
+                     s: TaskStreams[_]) = {
+    val log = s.log
+
+    if ( options.featuresPresent ) {
+      log.debug("JVM Settings: %s".format(jvmSettings))
+      log.debug("Cucumber Options: %s".format(options))
+      log.debug("Cucumber Output: %s".format(output))
+
+      runCucumber(args, jvmSettings, options, output, log)
+    }
+    else {
+      log.info("No features directory found. Skipping for curent project.")
+      0
+    }
+  }
+
+  private def runCucumber(args: Seq[String],
+                          jvmSettings: JvmSettings,
+                          options: Options,
+                          output: Output,
+                          log: Logger) = {
+    def tagsFromArgs = args.filter(isATag).toList
+    def namesFromArgs = args.filter(isNotATag).toList
+
+    def isATag(arg: String) = arg.startsWith("@") || arg.startsWith("~")
+    def isNotATag(arg: String) = !isATag(arg)
+
+    log.info("Running cucumber...")
+    options.beforeFunc()
+    val result = launchCucumberInSeparateJvm(jvmSettings, options, output, tagsFromArgs, namesFromArgs)
+    options.afterFunc()
+    result
+  }
+
+  private def launchCucumberInSeparateJvm(jvmSettings: JvmSettings, 
+                                          options: Options,
+                                          output: Output,
+                                          tags: List[String], 
+                                          names: List[String]): Int = {
+    def makeOptionsList(options: List[String], flag: String) = options flatMap(List(flag, _))
+
+    val cucumberParams = ("--glue" :: options.basePackage :: Nil) ++
+                         options.extraOptions ++ 
+                         output.options ++
+                         makeOptionsList(tags, "--tags") ++ 
+                         makeOptionsList(names, "--name") ++
+                         (options.featuresDir.getPath :: Nil)
+    JvmLauncher(jvmSettings).launch(cucumberParams)
+  }
+}

Diff for: src/main/scala/templemore/xsbt/cucumber/CucumberPlugin.scala renamed to plugin/src/main/scala/templemore/sbt/cucumber/CucumberPlugin.scala

@@ -0,0 +1,17 @@
+package templemore.sbt.cucumber
+
+import java.io.File
+
+/**
+ * The options to pass to cucumber.
+ *
+ * @author Chris Turner
+ */
+case class Options(featuresDir: File,
+                   basePackage: String,
+                   extraOptions: List[String],
+                   beforeFunc: () => Unit,
+                   afterFunc: () => Unit) {
+
+  def featuresPresent = featuresDir.exists
+}

Diff for: plugin/src/main/scala/templemore/sbt/cucumber/Integration.scala

@@ -1,12 +1,14 @@
-package templemore.xsbt.cucumber
+package templemore.sbt.cucumber
 
 import java.io.File
 
 /**
+ * Defines the output options for running cucumber.
+ *
  * @author Chris Turner
  */
-case class CucumberOutput(prettyReport: Boolean, htmlReport: Boolean, junitReport: Boolean, jsonReport: Boolean,
-                          prettyReportFile: File, htmlReportDir: File, junitReportFile: File, jsonReportFile: File) {
+case class Output(prettyReport: Boolean, htmlReport: Boolean, junitReport: Boolean, jsonReport: Boolean,
+                  prettyReportFile: File, htmlReportDir: File, junitReportFile: File, jsonReportFile: File) {
 
   def options: List[String] = {
     (if (prettyReport) {
@@ -27,4 +29,4 @@ case class CucumberOutput(prettyReport: Boolean, htmlReport: Boolean, junitRepor
        "--format" :: "json-pretty:%s".format(jsonReportFile.getPath) :: Nil
      } else Nil)
   }
-}
+}

Diff for: plugin/src/main/scala/templemore/sbt/cucumber/Options.scala

@@ -0,0 +1,42 @@
+package templemore.sbt.util
+
+import sbt._
+import java.io.File
+import sbt.OutputStrategy
+
+/**
+ * Launches a new JVM with the given options.
+ *
+ * @author Chris Turner
+ */
+case class JvmLauncher(settings: JvmSettings) {
+
+  private val maxMemory = settings.overrideMaxMemory.getOrElse("256M")
+  private val maxPermGen = settings.overrideMaxPermGen.getOrElse("64M")
+
+  private val jvmArgs = ("-classpath" :: makeClasspath ::
+                        ("-Xmx%s" format maxMemory) :: ("-XX:MaxPermSize=%s" format maxPermGen) :: Nil) ++
+                        makeSystemProperties ++ settings.jvmOptions
+
+  def launch(params: List[String]): Int = {
+    val args = jvmArgs ++ (settings.mainClass :: params)
+    settings.outputStrategy.asInstanceOf[LoggedOutput].logger.debug(args mkString " ")
+    Fork.java(None, args, None, Map.empty[String, String], settings.outputStrategy)
+  }
+
+  protected def makeClasspath = settings.classpath map (_.getPath) mkString File.pathSeparator
+  protected def makeSystemProperties = settings.systemProperties.toList map (entry => "-D%s=%s".format(entry._1, entry._2))
+}
+
+/**
+ * The options to pass to the JVM.
+ *
+ * @author Chris Turner
+ */
+case class JvmSettings(classpath: List[File],
+                       mainClass: String,
+                       outputStrategy: OutputStrategy,
+                       systemProperties: Map[String, String],
+                       jvmOptions: List[String],
+                       overrideMaxMemory: Option[String],
+                       overrideMaxPermGen: Option[String])

Diff for: src/main/scala/templemore/xsbt/cucumber/CucumberOutput.scala renamed to plugin/src/main/scala/templemore/sbt/cucumber/Output.scala

@@ -0,0 +1,35 @@
+import sbt._
+import Keys._
+
+object Settings {
+  val buildOrganization = "templemore"
+  val buildScalaVersion = "2.9.2"
+  val buildVersion      = "0.7.0"
+
+  val buildSettings = Defaults.defaultSettings ++
+                      Seq (organization  := buildOrganization,
+                           scalaVersion  := buildScalaVersion,
+                           version       := buildVersion,
+                           scalacOptions += "-deprecation")
+}
+
+object Dependencies {
+  val testInterface = "org.scala-tools.testing" % "test-interface" % "0.5"
+}
+
+object Build extends Build {
+  import Dependencies._
+  import Settings._
+
+  lazy val parentProject = Project("sbt-cucumber-parent", file ("."),
+    settings = buildSettings) aggregate (pluginProject, integrationProject)
+
+  lazy val pluginProject = Project("sbt-cucumber-plugin", file ("plugin"),
+    settings = buildSettings ++ 
+               Seq(sbtPlugin := true))
+
+  lazy val integrationProject = Project ("sbt-cucumber-integration", file ("integration"),
+    settings = buildSettings ++ 
+               Seq(crossScalaVersions := Seq("2.9.2", "2.10.0-RC1"),
+                   libraryDependencies ++= Seq(testInterface)))
+}