Improved the way that output is managed and generated

skipoleschris · skipoleschris · commit f61c7192891f · 2012-06-22T09:24:29.000+01:00
diff --git a/src/main/scala/templemore/xsbt/cucumber/CucumberIntegration.scala b/src/main/scala/templemore/xsbt/cucumber/CucumberIntegration.scala
@@ -8,32 +8,19 @@ import std.TaskStreams
  */
 trait CucumberIntegration {
 
-  protected def optionsForReporting(htmlReportDir: Option[File],
-                                    jsonReportFile: Option[File],
-                                    junitReportFile: Option[File]): List[String] = {
-    (Some("--format" :: "pretty" :: Nil) ::
-     (htmlReportDir map { dir => 
-       dir.mkdirs()
-       "--format" :: "html:%s".format(dir.getPath) :: Nil }) ::
-     (jsonReportFile map { file => 
-       file.getParentFile.mkdirs()
-       "--format" :: "json-pretty:%s".format(file.getPath) :: Nil }) ::
-     (junitReportFile map { file => 
-       file.getParentFile.mkdirs()
-       "--format" :: "junit:%s".format(file.getPath) :: Nil }) :: Nil).flatten.flatten
-  }
-
   protected def testWithCucumber(args: Seq[String],
                                  cucumberSettings: CucumberSettings,
                                  cucumberOptions: CucumberOptions,
+                                 cucumberOutput: CucumberOutput,
                                  s: TaskStreams[_]) = {
     val log = s.log
 
     if ( cucumberOptions.featuresPresent ) {
       log.debug("Cucumber Settings: %s".format(cucumberSettings))
       log.debug("Cucumber Options: %s".format(cucumberOptions))
+      log.debug("Cucumber Output: %s".format(cucumberOutput))
 
-      runCucumber(args, cucumberSettings, cucumberOptions, log)
+      runCucumber(args, cucumberSettings, cucumberOptions, cucumberOutput, log)
     }
     else {
       log.info("No features directory found. Skipping for curent project.")
@@ -44,6 +31,7 @@ trait CucumberIntegration {
   private def runCucumber(args: Seq[String],
                           cucumberSettings: CucumberSettings,
                           cucumberOptions: CucumberOptions,
+                          cucumberOutput: CucumberOutput,
                           log: Logger) = {
     def tagsFromArgs(args: Seq[String]) = args.filter(isATag).toList
     def namesFromArgs(args: Seq[String]) = args.filter(isNotATag).toList
@@ -56,7 +44,7 @@ trait CucumberIntegration {
     val cucumber = Cucumber(cucumberSettings.classpath, cucumberSettings.outputStrategy,
                             Some(cucumberSettings.maxMemory), Some(cucumberSettings.maxPermGen))
     val result = cucumber.cuke(cucumberOptions.featuresDir, cucumberOptions.basePackage,
-                               cucumberOptions.options, tagsFromArgs(args), namesFromArgs(args))
+                               cucumberOptions.options ++ cucumberOutput.options, tagsFromArgs(args), namesFromArgs(args))
     cucumberOptions.afterFunc()
     result
   }
diff --git a/src/main/scala/templemore/xsbt/cucumber/CucumberOutput.scala b/src/main/scala/templemore/xsbt/cucumber/CucumberOutput.scala
@@ -0,0 +1,30 @@
+package templemore.xsbt.cucumber
+
+import java.io.File
+
+/**
+ * @author Chris Turner
+ */
+case class CucumberOutput(prettyReport: Boolean, htmlReport: Boolean, junitReport: Boolean, jsonReport: Boolean,
+                          prettyReportFile: File, htmlReportDir: File, junitReportFile: File, jsonReportFile: File) {
+
+  def options: List[String] = {
+    (if (prettyReport) {
+       prettyReportFile.getParentFile.mkdirs()
+       "--format" :: "progress" :: "--format" :: "pretty:%s".format(prettyReportFile.getPath) :: Nil
+     }
+     else "--format" :: "pretty" :: Nil) ++
+    (if ( htmlReport) {
+       htmlReportDir.mkdirs()
+       "--format" :: "html:%s".format(htmlReportDir.getPath) :: Nil
+     } else Nil) ++
+    (if ( junitReport) {
+       junitReportFile.getParentFile.mkdirs()
+       "--format" :: "junit:%s".format(junitReportFile.getPath) :: Nil
+     } else Nil) ++
+    (if ( jsonReport) {
+       jsonReportFile.getParentFile.mkdirs()
+       "--format" :: "json-pretty:%s".format(jsonReportFile.getPath) :: Nil
+     } else Nil)
+  }
+}
diff --git a/src/main/scala/templemore/xsbt/cucumber/CucumberPlugin.scala b/src/main/scala/templemore/xsbt/cucumber/CucumberPlugin.scala
@@ -17,23 +17,30 @@ object CucumberPlugin extends Plugin with CucumberIntegration {
   val cucumber = InputKey[Int]("cucumber")
   val cucumberTestSettings = TaskKey[CucumberSettings]("cucumber-settings")
   val cucumberOptions = TaskKey[CucumberOptions]("cucumber-options")
+  val cucumberOutput = TaskKey[CucumberOutput]("cucumber-output")
 
   val cucumberMaxMemory = SettingKey[String]("cucumber-max-memory")
   val cucumberMaxPermGen = SettingKey[String]("cucumber-max-perm-gen")
 
   val cucumberFeaturesDir = SettingKey[File]("cucumber-features-directory")
   val cucumberStepsBasePackage = SettingKey[String]("cucumber-steps-base-package")
-  val cucumberExtraOptions = SettingKey[Seq[String]]("cucumber-extra-options")
+  val cucumberExtraOptions = SettingKey[List[String]]("cucumber-extra-options")
 
-  val cucumberHtmlReportDir = SettingKey[Option[File]]("cucumber-html-report")
-  val cucumberJsonReportFile = SettingKey[Option[File]]("cucumber-json-report")
-  val cucumberJunitReportFile = SettingKey[Option[File]]("cucumber-junit-report")
+  val cucumberPrettyReport = SettingKey[Boolean]("cucumber-pretty-report")
+  val cucumberHtmlReport = SettingKey[Boolean]("cucumber-html-report")
+  val cucumberJunitReport = SettingKey[Boolean]("cucumber-junit-report")
+  val cucumberJsonReport = SettingKey[Boolean]("cucumber-json-report")
+
+  val cucumberPrettyReportFile = SettingKey[File]("cucumber-pretty-report-file")
+  val cucumberHtmlReportDir = SettingKey[File]("cucumber-html-report-dir")
+  val cucumberJsonReportFile = SettingKey[File]("cucumber-json-report-file")
+  val cucumberJunitReportFile = SettingKey[File]("cucumber-junit-report-file")
 
   val cucumberBefore = SettingKey[LifecycleCallback]("cucumber-before")
   val cucumberAfter = SettingKey[LifecycleCallback]("cucumber-after")
 
   protected def cucumberTask(argTask: TaskKey[Seq[String]]) =
-    (argTask, cucumberTestSettings, cucumberOptions, streams) map(testWithCucumber)
+    (argTask, cucumberTestSettings, cucumberOptions, cucumberOutput, streams) map(testWithCucumber)
 
   protected def cucumberSettingsTask: Initialize[Task[CucumberSettings]] =
     (cucumberMaxMemory, cucumberMaxPermGen, fullClasspath in Test, streams) map {
@@ -44,10 +51,17 @@ object CucumberPlugin extends Plugin with CucumberIntegration {
 
   protected def cucumberOptionsTask: Initialize[Task[CucumberOptions]] =
     (cucumberFeaturesDir, cucumberStepsBasePackage, cucumberExtraOptions,
-     cucumberHtmlReportDir, cucumberJsonReportFile, cucumberJunitReportFile,
      cucumberBefore, cucumberAfter) map {
-      (fd, bp, o, htmlRD, jsonRF, junitRF, bf, af) => {
-        CucumberOptions(fd, bp, optionsForReporting(htmlRD, jsonRF, junitRF) ++ o, bf, af)
+      (fd, bp, o, bf, af) => {
+        CucumberOptions(fd, bp, o, bf, af)
+      }
+    }
+
+  protected def cucumberOutputTask: Initialize[Task[CucumberOutput]] =
+    (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)
       }
     }
 
@@ -65,6 +79,7 @@ object CucumberPlugin extends Plugin with CucumberIntegration {
     cucumber <<= inputTask(cucumberTask),
     cucumberTestSettings <<= cucumberSettingsTask,
     cucumberOptions <<= cucumberOptionsTask,
+    cucumberOutput <<= cucumberOutputTask,
 
     cucumberMaxMemory := "256M",
     cucumberMaxPermGen := "64M",
@@ -73,9 +88,15 @@ object CucumberPlugin extends Plugin with CucumberIntegration {
     cucumberStepsBasePackage := "",
     cucumberExtraOptions := List[String](),
 
-    cucumberHtmlReportDir := None,
-    cucumberJsonReportFile := None,
-    cucumberJunitReportFile := None,
+    cucumberPrettyReport := false,
+    cucumberHtmlReport := false,
+    cucumberJunitReport := false,
+    cucumberJsonReport := false,
+
+    cucumberPrettyReportFile <<= (scalaVersion, target) { (sv, t) => t / "scala-%s".format(sv) / "cucumber.txt" },
+    cucumberHtmlReportDir <<= (scalaVersion, target) { (sv, t) => t / "scala-%s".format(sv) / "cucumber-report" },
+    cucumberJsonReportFile <<= (scalaVersion, target) { (sv, t) => t / "scala-%s".format(sv) / "cucumber.json" },
+    cucumberJunitReportFile <<= (scalaVersion, target) { (sv, t) => t / "scala-%s".format(sv) / "cucumber.xml" },
 
     cucumberBefore := defaultBefore,
     cucumberAfter := defaultAfter
diff --git a/testProjects/multiModuleTestProject/project/Build.scala b/testProjects/multiModuleTestProject/project/Build.scala
@@ -11,7 +11,9 @@ object BuildSettings {
                       Seq (organization := buildOrganization,
                            scalaVersion := buildScalaVersion,
                            version      := buildVersion) ++
-                      CucumberPlugin.cucumberSettings
+                      CucumberPlugin.cucumberSettings ++
+                      Seq (CucumberPlugin.cucumberHtmlReport := true,
+                           CucumberPlugin.cucumberPrettyReport := true)
 }
 
 object Dependencies {
diff --git a/testProjects/testProject/build.sbt b/testProjects/testProject/build.sbt
@@ -14,8 +14,8 @@ seq(cucumberSettings : _*)
 
 cucumberStepsBasePackage := "test"
 
-cucumberHtmlReportDir <<= (target) { d => Some(d / "cucumber-report") }
+cucumberHtmlReport := true
 
-cucumberJsonReportFile <<= (target) { f => Some(f / "cucumber.json") }
+cucumberJunitReport := true 
 
-cucumberJunitReportFile <<= (target) { f => Some(f / "cucumber-junit.xml") }
+cucumberJsonReport := true
