Merge pull request #182 from cucumber/scala3prep

refactor: 💡 Split ScalaDsl in multiple files

Author: gaeljw

cucumber-scala/src/main/scala/io/cucumber/scala/BaseScalaDsl.scala

@@ -0,0 +1,12 @@
+package io.cucumber.scala
+
+private[scala] trait BaseScalaDsl {
+
+  val NO_REPLACEMENT = Seq[String]()
+  val EMPTY_TAG_EXPRESSION = ""
+  val DEFAULT_BEFORE_ORDER = 1000
+  val DEFAULT_AFTER_ORDER = 1000
+
+  private[scala] val registry: ScalaDslRegistry = new ScalaDslRegistry()
+
+}

cucumber-scala/src/main/scala/io/cucumber/scala/DataTableTypeDsl.scala

@@ -0,0 +1,97 @@
+package io.cucumber.scala
+
+import scala.reflect.ClassTag
+
+private[scala] trait DataTableTypeDsl extends BaseScalaDsl {
+
+  /** Register a data table type.
+    */
+  def DataTableType: DataTableTypeBody = DataTableType(NO_REPLACEMENT)
+
+  /** Register a data table type with a replacement.
+    * <p>
+    * A data table can only represent absent and non-empty strings. By replacing
+    * a known value (for example [empty]) a data table can also represent
+    * empty strings.
+    *
+    * @param replaceWithEmptyString a string that will be replaced with an empty string.
+    */
+  def DataTableType(replaceWithEmptyString: String): DataTableTypeBody =
+    DataTableType(Seq(replaceWithEmptyString))
+
+  private def DataTableType(replaceWithEmptyString: Seq[String]) =
+    new DataTableTypeBody(replaceWithEmptyString)
+
+  final class DataTableTypeBody(replaceWithEmptyString: Seq[String]) {
+
+    def apply[T](
+        body: DataTableEntryDefinitionBody[T]
+    )(implicit ev: ClassTag[T]): Unit = {
+      registry.registerDataTableType(
+        ScalaDataTableEntryTypeDetails[T](replaceWithEmptyString, body, ev)
+      )
+    }
+
+    def apply[T](
+        body: DataTableOptionalEntryDefinitionBody[T]
+    )(implicit ev: ClassTag[T]): Unit = {
+      registry.registerDataTableType(
+        ScalaDataTableOptionalEntryTypeDetails[T](
+          replaceWithEmptyString,
+          body,
+          ev
+        )
+      )
+    }
+
+    def apply[T](
+        body: DataTableRowDefinitionBody[T]
+    )(implicit ev: ClassTag[T]): Unit = {
+      registry.registerDataTableType(
+        ScalaDataTableRowTypeDetails[T](replaceWithEmptyString, body, ev)
+      )
+    }
+
+    def apply[T](
+        body: DataTableOptionalRowDefinitionBody[T]
+    )(implicit ev: ClassTag[T]): Unit = {
+      registry.registerDataTableType(
+        ScalaDataTableOptionalRowTypeDetails[T](
+          replaceWithEmptyString,
+          body,
+          ev
+        )
+      )
+    }
+
+    def apply[T](
+        body: DataTableCellDefinitionBody[T]
+    )(implicit ev: ClassTag[T]): Unit = {
+      registry.registerDataTableType(
+        ScalaDataTableCellTypeDetails[T](replaceWithEmptyString, body, ev)
+      )
+    }
+
+    def apply[T](
+        body: DataTableOptionalCellDefinitionBody[T]
+    )(implicit ev: ClassTag[T]): Unit = {
+      registry.registerDataTableType(
+        ScalaDataTableOptionalCellTypeDetails[T](
+          replaceWithEmptyString,
+          body,
+          ev
+        )
+      )
+    }
+
+    def apply[T](
+        body: DataTableDefinitionBody[T]
+    )(implicit ev: ClassTag[T]): Unit = {
+      registry.registerDataTableType(
+        ScalaDataTableTableTypeDetails[T](replaceWithEmptyString, body, ev)
+      )
+    }
+
+  }
+
+}

cucumber-scala/src/main/scala/io/cucumber/scala/DefaultTransformerDsl.scala

@@ -0,0 +1,90 @@
+package io.cucumber.scala
+
+import io.cucumber.scala.Aliases.{
+  DefaultDataTableCellTransformerBody,
+  DefaultDataTableEntryTransformerBody,
+  DefaultParameterTransformerBody
+}
+
+private[scala] trait DefaultTransformerDsl extends BaseScalaDsl {
+
+  /** Register default parameter type transformer.
+    *
+    * @param body converts `String` argument to an instance of the `Type` argument
+    */
+  def DefaultParameterTransformer(
+      body: DefaultParameterTransformerBody
+  ): Unit = {
+    registry.registerDefaultParameterTransformer(
+      ScalaDefaultParameterTransformerDetails(body)
+    )
+  }
+
+  /** Register default data table cell transformer.
+    *
+    * @param body converts `String` argument to an instance of the `Type` argument
+    */
+  def DefaultDataTableCellTransformer(
+      body: DefaultDataTableCellTransformerBody
+  ): Unit = {
+    DefaultDataTableCellTransformer(NO_REPLACEMENT)(body)
+  }
+
+  /** Register default data table cell transformer with a replacement.
+    * <p>
+    * A data table can only represent absent and non-empty strings. By replacing
+    * a known value (for example [empty]) a data table can also represent
+    * empty strings.
+    * *
+    *
+    * @param replaceWithEmptyString a string that will be replaced with an empty string.
+    * @param body                   converts `String` argument to an instance of the `Type` argument
+    */
+  def DefaultDataTableCellTransformer(
+      replaceWithEmptyString: String
+  )(body: DefaultDataTableCellTransformerBody): Unit = {
+    DefaultDataTableCellTransformer(Seq(replaceWithEmptyString))(body)
+  }
+
+  private def DefaultDataTableCellTransformer(
+      replaceWithEmptyString: Seq[String]
+  )(body: DefaultDataTableCellTransformerBody): Unit = {
+    registry.registerDefaultDataTableCellTransformer(
+      ScalaDefaultDataTableCellTransformerDetails(replaceWithEmptyString, body)
+    )
+  }
+
+  /** Register default data table entry transformer.
+    *
+    * @param body converts `Map[String,String]` argument to an instance of the `Type` argument
+    */
+  def DefaultDataTableEntryTransformer(
+      body: DefaultDataTableEntryTransformerBody
+  ): Unit = {
+    DefaultDataTableEntryTransformer(NO_REPLACEMENT)(body)
+  }
+
+  /** Register default data table cell transformer with a replacement.
+    * <p>
+    * A data table can only represent absent and non-empty strings. By replacing
+    * a known value (for example [empty]) a data table can also represent
+    * empty strings.
+    *
+    * @param replaceWithEmptyString a string that will be replaced with an empty string.
+    * @param body                   converts `Map[String,String]` argument to an instance of the `Type` argument
+    */
+  def DefaultDataTableEntryTransformer(
+      replaceWithEmptyString: String
+  )(body: DefaultDataTableEntryTransformerBody): Unit = {
+    DefaultDataTableEntryTransformer(Seq(replaceWithEmptyString))(body)
+  }
+
+  private def DefaultDataTableEntryTransformer(
+      replaceWithEmptyString: Seq[String]
+  )(body: DefaultDataTableEntryTransformerBody): Unit = {
+    registry.registerDefaultDataTableEntryTransformer(
+      ScalaDefaultDataTableEntryTransformerDetails(replaceWithEmptyString, body)
+    )
+  }
+
+}

cucumber-scala/src/main/scala/io/cucumber/scala/DocStringTypeDsl.scala

@@ -0,0 +1,24 @@
+package io.cucumber.scala
+
+import io.cucumber.scala.Aliases.DocStringDefinitionBody
+
+import scala.reflect.ClassTag
+
+private[scala] trait DocStringTypeDsl extends BaseScalaDsl {
+
+  /** Register doc string type.
+    *
+    * @param contentType Name of the content type.
+    * @param body        a function that creates an instance of <code>T</code>
+    *                    from the doc string
+    * @tparam T type to convert to
+    */
+  def DocStringType[T](
+      contentType: String
+  )(body: DocStringDefinitionBody[T])(implicit ev: ClassTag[T]): Unit = {
+    registry.registerDocStringType(
+      ScalaDocStringTypeDetails[T](contentType, body, ev)
+    )
+  }
+
+}

cucumber-scala/src/main/scala/io/cucumber/scala/HookDsl.scala

@@ -0,0 +1,129 @@
+package io.cucumber.scala
+
+private[scala] trait HookDsl extends BaseScalaDsl {
+  self =>
+
+  /** Defines an before hook.
+    */
+  def Before: HookBody = Before(EMPTY_TAG_EXPRESSION, DEFAULT_BEFORE_ORDER)
+
+  /** Defines an before hook.
+    *
+    * @param tagExpression a tag expression, if the expression applies to the current scenario this hook will be executed
+    */
+  def Before(tagExpression: String): HookBody =
+    Before(tagExpression, DEFAULT_BEFORE_ORDER)
+
+  /** Defines an before hook.
+    *
+    * @param order the order in which this hook should run. Higher numbers are run first
+    */
+  def Before(order: Int): HookBody = Before(EMPTY_TAG_EXPRESSION, order)
+
+  /** Defines an before hook.
+    *
+    * @param tagExpression a tag expression, if the expression applies to the current scenario this hook will be executed
+    * @param order         the order in which this hook should run. Higher numbers are run first
+    */
+  def Before(tagExpression: String, order: Int) =
+    new HookBody(HookType.BEFORE, tagExpression, order, Utils.frame(self))
+
+  /** Defines an before step hook.
+    */
+  def BeforeStep: HookBody =
+    BeforeStep(EMPTY_TAG_EXPRESSION, DEFAULT_BEFORE_ORDER)
+
+  /** Defines an before step hook.
+    *
+    * @param tagExpression a tag expression, if the expression applies to the current scenario this hook will be executed
+    */
+  def BeforeStep(tagExpression: String): HookBody =
+    BeforeStep(tagExpression, DEFAULT_BEFORE_ORDER)
+
+  /** Defines an before step hook.
+    *
+    * @param order the order in which this hook should run. Higher numbers are run first
+    */
+  def BeforeStep(order: Int): HookBody = BeforeStep(EMPTY_TAG_EXPRESSION, order)
+
+  /** Defines an before step hook.
+    *
+    * @param tagExpression a tag expression, if the expression applies to the current scenario this hook will be executed
+    * @param order         the order in which this hook should run. Higher numbers are run first
+    */
+  def BeforeStep(tagExpression: String, order: Int) =
+    new HookBody(HookType.BEFORE_STEP, tagExpression, order, Utils.frame(self))
+
+  /** Defines and after hook.
+    */
+  def After: HookBody = After(EMPTY_TAG_EXPRESSION, DEFAULT_AFTER_ORDER)
+
+  /** Defines and after hook.
+    *
+    * @param tagExpression a tag expression, if the expression applies to the current scenario this hook will be executed
+    */
+  def After(tagExpression: String): HookBody =
+    After(tagExpression, DEFAULT_AFTER_ORDER)
+
+  /** Defines and after hook.
+    *
+    * @param order the order in which this hook should run. Higher numbers are run first
+    */
+  def After(order: Int): HookBody = After(EMPTY_TAG_EXPRESSION, order)
+
+  /** Defines and after hook.
+    *
+    * @param tagExpression a tag expression, if the expression applies to the current scenario this hook will be executed
+    * @param order         the order in which this hook should run. Higher numbers are run first
+    */
+  def After(tagExpression: String, order: Int) =
+    new HookBody(HookType.AFTER, tagExpression, order, Utils.frame(self))
+
+  /** Defines and after step hook.
+    */
+  def AfterStep: HookBody = AfterStep(EMPTY_TAG_EXPRESSION, DEFAULT_AFTER_ORDER)
+
+  /** Defines and after step hook.
+    *
+    * @param tagExpression a tag expression, if the expression applies to the current scenario this hook will be executed
+    */
+  def AfterStep(tagExpression: String): HookBody =
+    AfterStep(tagExpression, DEFAULT_AFTER_ORDER)
+
+  /** Defines and after step hook.
+    *
+    * @param order the order in which this hook should run. Higher numbers are run first
+    */
+  def AfterStep(order: Int): HookBody = AfterStep(EMPTY_TAG_EXPRESSION, order)
+
+  /** Defines and after step hook.
+    *
+    * @param tagExpression a tag expression, if the expression applies to the current scenario this hook will be executed
+    * @param order         the order in which this hook should run. Higher numbers are run first
+    */
+  def AfterStep(tagExpression: String, order: Int) =
+    new HookBody(HookType.AFTER_STEP, tagExpression, order, Utils.frame(self))
+
+  final class HookBody(
+      hookType: HookType,
+      tagExpression: String,
+      order: Int,
+      frame: StackTraceElement
+  ) {
+
+    // When a HookBody is created, we want to ensure that the apply method is called
+    // To be able to check this, we notice the registry to expect a hook
+    registry.expectHook(hookType, frame)
+
+    def apply(body: => Unit): Unit = {
+      apply(_ => body)
+    }
+
+    def apply(body: Scenario => Unit): Unit = {
+      val details = ScalaHookDetails(tagExpression, order, body)
+      registry.registerHook(hookType, details, frame)
+    }
+
+  }
+
+}

cucumber-scala/src/main/scala/io/cucumber/scala/HookType.scala

@@ -0,0 +1,15 @@
+package io.cucumber.scala
+
+sealed trait HookType
+
+object HookType {
+
+  case object BEFORE extends HookType
+
+  case object BEFORE_STEP extends HookType
+
+  case object AFTER extends HookType
+
+  case object AFTER_STEP extends HookType
+
+}