Merge pull request #40 from cucumber/hooks-no-parameters

Allow to define hooks with by name body

Author: gaeljw

CHANGELOG.md

@@ -17,6 +17,7 @@ See also the [CHANGELOG](https://github.com/cucumber/cucumber-jvm/blob/master/CH
   - See [Transformers](docs/transformers.md)
 - [Transformers] Add optional `JacksonDefaultDataTableEntryTransformer` ([#31](https://github.com/cucumber/cucumber-jvm-scala/issues/31) Gaël Jourdan-Weil)
   - See [here](docs/default_jackson_datatable_transformer.md)
+- [Scala DSL] Support hooks with by name body ([#26](https://github.com/cucumber/cucumber-jvm-scala/issues/26) Gaël Jourdan-Weil)
 
 ### Changed
 

docs/hooks.md

@@ -17,6 +17,11 @@ Scenario hooks run for every scenario.
 Before { scenario : Scenario =>
   // Do something before each scenario
 }
+
+// Or:
+Before {
+  // Do something before each scenario
+}
 ```
 
 ### After
@@ -27,6 +32,11 @@ Before { scenario : Scenario =>
 After { scenario : Scenario =>
   // Do something after each scenario
 }
+
+// Or:
+After {
+  // Do something after each scenario
+}
 ```
 
 ## Step hooks
@@ -39,6 +49,11 @@ Step hooks invoked before and after a step.
 BeforeStep { scenario : Scenario =>
   // Do something before step
 }
+
+// Or:
+BeforeStep {
+  // Do something before step
+}
 ```
 
 ### AfterStep
@@ -47,14 +62,19 @@ BeforeStep { scenario : Scenario =>
 AfterStep { scenario : Scenario =>
   // Do something after step
 }
+
+// Or:
+AfterStep {
+  // Do something after step
+}
 ```
 
 ## Conditional hooks
 
 Hooks can be conditionally selected for execution based on the tags of the scenario.
 
 ```scala
-Before("@browser and not @headless") { _ =>
+Before("@browser and not @headless") { 
   // Do something before each scenario with tag @browser but not @headless
 }
 ```
@@ -64,11 +84,11 @@ Before("@browser and not @headless") { _ =>
 You can define an order between multiple hooks.
 
 ```scala
-Before(10) { _ =>
+Before(10) { 
   // Do something before each scenario
 }
 
-Before(20) { _ =>
+Before(20) { 
   // Do something before each scenario
 }
 ```
@@ -79,7 +99,7 @@ The **default order is 1000**.
 
 You mix up conditional and order hooks with following syntax:
 ```scala
-Before("@browser and not @headless", 10) { _ =>
+Before("@browser and not @headless", 10) {
   // Do something before each scenario
 }
 ```

scala/sources/src/main/scala/io/cucumber/scala/Aliases.scala

@@ -5,7 +5,7 @@ package io.cucumber.scala
  */
 object Aliases {
 
-  type HookBody = Scenario => Unit
+  type HookDefinitionBody = Scenario => Unit
 
   type StepDefinitionBody = () => Unit
 

scala/sources/src/main/scala/io/cucumber/scala/ScalaDsl.scala

@@ -2,7 +2,7 @@ package io.cucumber.scala
 
 import java.lang.reflect.{ParameterizedType, Type}
 
-import io.cucumber.scala.Aliases.{DefaultDataTableCellTransformerBody, DefaultDataTableEntryTransformerBody, DefaultParameterTransformerBody, DocStringDefinitionBody, HookBody}
+import io.cucumber.scala.Aliases._
 
 import scala.reflect.ClassTag
 
@@ -28,70 +28,72 @@ trait ScalaDsl extends BaseScalaDsl with StepDsl with HookDsl with DataTableType
 
 private[scala] trait HookDsl extends BaseScalaDsl {
 
-  // TODO support Before/After with no parameter
+  private sealed trait HookType
 
-  def Before(body: HookBody): Unit = {
-    Before(EMPTY_TAG_EXPRESSION, DEFAULT_BEFORE_ORDER)(body)
-  }
+  private object HookType {
 
-  def Before(tagExpression: String)(body: HookBody): Unit = {
-    Before(tagExpression, DEFAULT_BEFORE_ORDER)(body)
-  }
+    case object BEFORE extends HookType
 
-  def Before(order: Int)(body: HookBody): Unit = {
-    Before(EMPTY_TAG_EXPRESSION, order)(body)
-  }
+    case object BEFORE_STEP extends HookType
 
-  def Before(tagExpression: String, order: Int)(body: HookBody): Unit = {
-    registry.beforeHooks += ScalaHookDetails(tagExpression, order, body)
-  }
+    case object AFTER extends HookType
 
-  def BeforeStep(body: HookBody): Unit = {
-    BeforeStep(EMPTY_TAG_EXPRESSION, DEFAULT_BEFORE_ORDER)(body)
-  }
+    case object AFTER_STEP extends HookType
 
-  def BeforeStep(tagExpression: String)(body: HookBody): Unit = {
-    BeforeStep(tagExpression, DEFAULT_BEFORE_ORDER)(body)
   }
 
-  def BeforeStep(order: Int)(body: HookBody): Unit = {
-    BeforeStep(EMPTY_TAG_EXPRESSION, order)(body)
-  }
+  def Before: HookBody = Before(EMPTY_TAG_EXPRESSION, DEFAULT_BEFORE_ORDER)
 
-  def BeforeStep(tagExpression: String, order: Int)(body: HookBody): Unit = {
-    registry.beforeStepHooks += ScalaHookDetails(tagExpression, order, body)
-  }
+  def Before(tagExpression: String): HookBody = Before(tagExpression, DEFAULT_BEFORE_ORDER)
 
-  def After(body: HookBody): Unit = {
-    After(EMPTY_TAG_EXPRESSION, DEFAULT_AFTER_ORDER)(body)
-  }
+  def Before(order: Int): HookBody = Before(EMPTY_TAG_EXPRESSION, order)
 
-  def After(tagExpression: String)(body: HookBody): Unit = {
-    After(tagExpression, DEFAULT_AFTER_ORDER)(body)
-  }
+  def Before(tagExpression: String, order: Int): HookBody = new HookBody(HookType.BEFORE, tagExpression, order)
 
-  def After(order: Int)(body: HookBody): Unit = {
-    After(EMPTY_TAG_EXPRESSION, order)(body)
-  }
+  def BeforeStep: HookBody = BeforeStep(EMPTY_TAG_EXPRESSION, DEFAULT_BEFORE_ORDER)
 
-  def After(tagExpression: String, order: Int)(body: HookBody): Unit = {
-    registry.afterHooks += ScalaHookDetails(tagExpression, order, body)
-  }
+  def BeforeStep(tagExpression: String): HookBody = BeforeStep(tagExpression, DEFAULT_BEFORE_ORDER)
 
-  def AfterStep(body: HookBody): Unit = {
-    AfterStep(EMPTY_TAG_EXPRESSION, DEFAULT_AFTER_ORDER)(body)
-  }
+  def BeforeStep(order: Int): HookBody = BeforeStep(EMPTY_TAG_EXPRESSION, order)
 
-  def AfterStep(tagExpression: String)(body: HookBody): Unit = {
-    AfterStep(tagExpression, DEFAULT_AFTER_ORDER)(body)
-  }
+  def BeforeStep(tagExpression: String, order: Int): HookBody = new HookBody(HookType.BEFORE_STEP, tagExpression, order)
 
-  def AfterStep(order: Int)(body: HookBody): Unit = {
-    AfterStep(EMPTY_TAG_EXPRESSION, order)(body)
-  }
+  def After: HookBody = After(EMPTY_TAG_EXPRESSION, DEFAULT_AFTER_ORDER)
+
+  def After(tagExpression: String): HookBody = After(tagExpression, DEFAULT_AFTER_ORDER)
+
+  def After(order: Int): HookBody = After(EMPTY_TAG_EXPRESSION, order)
+
+  def After(tagExpression: String, order: Int): HookBody = new HookBody(HookType.AFTER, tagExpression, order)
+
+  def AfterStep: HookBody = AfterStep(EMPTY_TAG_EXPRESSION, DEFAULT_AFTER_ORDER)
+
+  def AfterStep(tagExpression: String): HookBody = AfterStep(tagExpression, DEFAULT_AFTER_ORDER)
+
+  def AfterStep(order: Int): HookBody = AfterStep(EMPTY_TAG_EXPRESSION, order)
+
+  def AfterStep(tagExpression: String, order: Int): HookBody = new HookBody(HookType.AFTER_STEP, tagExpression, order)
+
+  final class HookBody(hookType: HookType, tagExpression: String, order: Int) {
+
+    def apply(body: => Unit): Unit = {
+      apply(_ => body)
+    }
+
+    def apply(body: Scenario => Unit): Unit = {
+      val details = ScalaHookDetails(tagExpression, order, body)
+      hookType match {
+        case HookType.BEFORE =>
+          registry.beforeHooks += details
+        case HookType.BEFORE_STEP =>
+          registry.beforeStepHooks += details
+        case HookType.AFTER =>
+          registry.afterHooks += details
+        case HookType.AFTER_STEP =>
+          registry.afterStepHooks += details
+      }
+    }
 
-  def AfterStep(tagExpression: String, order: Int)(body: HookBody): Unit = {
-    registry.afterStepHooks += ScalaHookDetails(tagExpression, order, body)
   }
 
 }

scala/sources/src/main/scala/io/cucumber/scala/ScalaHookDefinition.scala

@@ -9,7 +9,7 @@ trait ScalaHookDefinition extends HookDefinition with AbstractGlueDefinition {
   override val location: StackTraceElement = new Exception().getStackTrace()(3)
 
   override def execute(state: TestCaseState): Unit = {
-    executeAsCucumber(hookDetails.body(new Scenario(state)))
+    executeAsCucumber(hookDetails.body.apply(new Scenario(state)))
   }
 
   override def getTagExpression: String = hookDetails.tagExpression

scala/sources/src/main/scala/io/cucumber/scala/ScalaHookDetails.scala

@@ -1,5 +1,5 @@
 package io.cucumber.scala
 
-import io.cucumber.scala.Aliases.HookBody
+import io.cucumber.scala.Aliases.HookDefinitionBody
 
-case class ScalaHookDetails(tagExpression: String, order: Int, body: HookBody)
+case class ScalaHookDetails(tagExpression: String, order: Int, body: HookDefinitionBody)