Implement DataTableType and DocStringType in the DSL

Author: gaeljw

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

@@ -0,0 +1,60 @@
+package io.cucumber.scala
+
+import io.cucumber.datatable.DataTable
+
+import scala.util.{Failure, Success, Try}
+import scala.collection.JavaConverters._
+
+trait AbstractDatatableElementTransformerDefinition extends AbstractGlueDefinition {
+
+  val emptyPatterns: Seq[String]
+
+  protected def replaceEmptyPatternsWithEmptyString(row: Seq[String]): Seq[String] = {
+    row.map(replaceEmptyPatternsWithEmptyString)
+  }
+
+  protected def replaceEmptyPatternsWithEmptyString(table: DataTable): DataTable = {
+    val rawWithEmptyStrings = table.cells().asScala
+      .map(_.asScala.toSeq)
+      .map(replaceEmptyPatternsWithEmptyString)
+      .map(_.asJava)
+      .toSeq
+      .asJava
+
+    DataTable.create(rawWithEmptyStrings, table.getTableConverter)
+  }
+
+  protected def replaceEmptyPatternsWithEmptyString(fromValue: Map[String, String]): Try[Map[String, String]] = {
+    val replacement = fromValue.toSeq.map { case (key, value) =>
+      val potentiallyEmptyKey = replaceEmptyPatternsWithEmptyString(key)
+      val potentiallyEmptyValue = replaceEmptyPatternsWithEmptyString(value)
+
+      (potentiallyEmptyKey, potentiallyEmptyValue)
+    }
+
+    if (containsDuplicateKey(replacement)) {
+      Failure(createDuplicateKeyAfterReplacement(fromValue))
+    } else {
+      Success(replacement.toMap)
+    }
+  }
+
+  protected def replaceEmptyPatternsWithEmptyString(t: String): String = {
+    if (emptyPatterns.contains(t)) {
+      ""
+    } else {
+      t
+    }
+  }
+
+  private def containsDuplicateKey(seq: Seq[(String, Any)]): Boolean = {
+    seq.map { case (key, _) => key }.toSet.size != seq.size
+  }
+
+  private def createDuplicateKeyAfterReplacement(fromValue: Map[String, String]): IllegalArgumentException = {
+    val conflict = emptyPatterns.filter(emptyPattern => fromValue.contains(emptyPattern))
+    val msg = s"After replacing ${conflict.headOption.getOrElse("")} and ${conflict.drop(1).headOption.getOrElse("")} with empty strings the datatable entry contains duplicate keys: $fromValue"
+    new IllegalArgumentException(msg)
+  }
+
+}

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

@@ -9,4 +9,6 @@ object Aliases {
 
   type StepDefinitionBody = () => Unit
 
+  type DocStringDefinitionBody[T] = String => T
+
 }

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

@@ -0,0 +1,59 @@
+package io.cucumber.scala
+
+import io.cucumber.datatable.DataTable
+
+trait DataTableEntryDefinitionBody[T] {
+
+  def transform(entry: Map[String, String]): T
+
+}
+
+trait DataTableRowDefinitionBody[T] {
+
+  def transform(row: Seq[String]): T
+
+}
+
+trait DataTableCellDefinitionBody[T] {
+
+  def transform(cell: String): T
+
+}
+
+trait DataTableDefinitionBody[T] {
+
+  def transform(dataTable: DataTable): T
+
+}
+
+object DataTableEntryDefinitionBody {
+
+  implicit def function1AsDataTableEntryDefinitionBody[T](f: (Map[String, String]) => T): DataTableEntryDefinitionBody[T] = new DataTableEntryDefinitionBody[T] {
+    override def transform(entry: Map[String, String]): T = f.apply(entry)
+  }
+
+}
+
+object DataTableRowDefinitionBody {
+
+  implicit def function1AsDataTableRowDefinitionBody[T](f: (Seq[String]) => T): DataTableRowDefinitionBody[T] = new DataTableRowDefinitionBody[T] {
+    override def transform(row: Seq[String]): T = f.apply(row)
+  }
+
+}
+
+object DataTableCellDefinitionBody {
+
+  implicit def function1AsDataTableCellDefinitionBody[T](f: (String) => T): DataTableCellDefinitionBody[T] = new DataTableCellDefinitionBody[T] {
+    override def transform(cell: String): T = f.apply(cell)
+  }
+
+}
+
+object DataTableDefinitionBody {
+
+  implicit def function1AsDataTableDefinitionBody[T](f: (DataTable) => T): DataTableDefinitionBody[T] = new DataTableDefinitionBody[T] {
+    override def transform(dataTable: DataTable): T = f.apply(dataTable)
+  }
+
+}

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

@@ -16,6 +16,8 @@ class GlueAdaptor(glue: Glue) {
     registry.afterHooks.map(ScalaHookDefinition(_, scenarioScoped)).foreach(glue.addAfterHook)
     registry.afterStepHooks.map(ScalaHookDefinition(_, scenarioScoped)).foreach(glue.addAfterStepHook)
     registry.beforeStepHooks.map(ScalaHookDefinition(_, scenarioScoped)).foreach(glue.addBeforeStepHook)
+    registry.docStringTypes.map(ScalaDocStringTypeDefinition(_, scenarioScoped)).foreach(glue.addDocStringType)
+    registry.dataTableTypes.map(ScalaDataTableTypeDefinition(_, scenarioScoped)).foreach(glue.addDataTableType)
   }
 
 }

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

@@ -0,0 +1,28 @@
+package io.cucumber.scala
+
+import io.cucumber.core.backend.ScenarioScoped
+import io.cucumber.datatable.{DataTableType, TableCellTransformer}
+
+trait ScalaDataTableCellDefinition[T] extends ScalaDataTableTypeDefinition {
+
+  val details: ScalaDataTableCellTypeDetails[T]
+
+  override val emptyPatterns: Seq[String] = details.emptyPatterns
+
+  override val location: StackTraceElement = new Exception().getStackTrace()(3)
+
+  private val transformer: TableCellTransformer[T] = new TableCellTransformer[T] {
+    override def transform(cell: String): T = {
+      details.body.transform(replaceEmptyPatternsWithEmptyString(cell))
+    }
+  }
+
+  override val dataTableType = new DataTableType(details.tag.runtimeClass, transformer)
+
+}
+
+class ScalaScenarioScopedDataTableCellDefinition[T](override val details: ScalaDataTableCellTypeDetails[T]) extends ScalaDataTableCellDefinition[T] with ScenarioScoped {
+}
+
+class ScalaGlobalDataTableCellDefinition[T](override val details: ScalaDataTableCellTypeDetails[T]) extends ScalaDataTableCellDefinition[T] {
+}

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

@@ -0,0 +1,28 @@
+package io.cucumber.scala
+
+import io.cucumber.core.backend.ScenarioScoped
+import io.cucumber.datatable.{DataTable, DataTableType, TableTransformer}
+
+trait ScalaDataTableDefinition[T] extends ScalaDataTableTypeDefinition {
+
+  val details: ScalaDataTableTableTypeDetails[T]
+
+  override val emptyPatterns: Seq[String] = details.emptyPatterns
+
+  override val location: StackTraceElement = new Exception().getStackTrace()(3)
+
+  private val transformer: TableTransformer[T] = new TableTransformer[T] {
+    override def transform(table: DataTable): T = {
+      details.body.transform(replaceEmptyPatternsWithEmptyString(table))
+    }
+  }
+
+  override val dataTableType = new DataTableType(details.tag.runtimeClass, transformer)
+
+}
+
+class ScalaScenarioScopedDataTableDefinition[T](override val details: ScalaDataTableTableTypeDetails[T]) extends ScalaDataTableDefinition[T] with ScenarioScoped {
+}
+
+class ScalaGlobalDataTableDefinition[T](override val details: ScalaDataTableTableTypeDetails[T]) extends ScalaDataTableDefinition[T] {
+}

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

@@ -0,0 +1,34 @@
+package io.cucumber.scala
+
+import java.util.{Map => JavaMap}
+
+import io.cucumber.core.backend.ScenarioScoped
+import io.cucumber.datatable.{DataTableType, TableEntryTransformer}
+
+import scala.collection.JavaConverters._
+
+trait ScalaDataTableEntryDefinition[T] extends ScalaDataTableTypeDefinition {
+
+  val details: ScalaDataTableEntryTypeDetails[T]
+
+  override val emptyPatterns: Seq[String] = details.emptyPatterns
+
+  override val location: StackTraceElement = new Exception().getStackTrace()(3)
+
+  private val transformer: TableEntryTransformer[T] = new TableEntryTransformer[T] {
+    override def transform(entry: JavaMap[String, String]): T = {
+      replaceEmptyPatternsWithEmptyString(entry.asScala.toMap)
+        .map(details.body.transform)
+        .get
+    }
+  }
+
+  override val dataTableType = new DataTableType(details.tag.runtimeClass, transformer)
+
+}
+
+class ScalaScenarioScopedDataTableEntryDefinition[T](override val details: ScalaDataTableEntryTypeDetails[T]) extends ScalaDataTableEntryDefinition[T] with ScenarioScoped {
+}
+
+class ScalaGlobalDataTableEntryDefinition[T](override val details: ScalaDataTableEntryTypeDetails[T]) extends ScalaDataTableEntryDefinition[T] {
+}

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

@@ -0,0 +1,32 @@
+package io.cucumber.scala
+
+import java.util.{List => JavaList}
+
+import io.cucumber.core.backend.ScenarioScoped
+import io.cucumber.datatable.{DataTableType, TableRowTransformer}
+
+import scala.collection.JavaConverters._
+
+trait ScalaDataTableRowDefinition[T] extends ScalaDataTableTypeDefinition {
+
+  val details: ScalaDataTableRowTypeDetails[T]
+
+  override val emptyPatterns: Seq[String] = details.emptyPatterns
+
+  override val location: StackTraceElement = new Exception().getStackTrace()(3)
+
+  private val transformer: TableRowTransformer[T] = new TableRowTransformer[T] {
+    override def transform(row: JavaList[String]): T = {
+      details.body.transform(replaceEmptyPatternsWithEmptyString(row.asScala.toSeq))
+    }
+  }
+
+  override val dataTableType = new DataTableType(details.tag.runtimeClass, transformer)
+
+}
+
+class ScalaScenarioScopedDataTableRowDefinition[T](override val details: ScalaDataTableRowTypeDetails[T]) extends ScalaDataTableRowDefinition[T] with ScenarioScoped {
+}
+
+class ScalaGlobalDataTableRowDefinition[T](override val details: ScalaDataTableRowTypeDetails[T]) extends ScalaDataTableRowDefinition[T] {
+}

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

@@ -0,0 +1,42 @@
+package io.cucumber.scala
+
+import io.cucumber.core.backend.DataTableTypeDefinition
+
+trait ScalaDataTableTypeDefinition
+  extends DataTableTypeDefinition
+    with AbstractDatatableElementTransformerDefinition {
+
+}
+
+object ScalaDataTableTypeDefinition {
+
+  def apply[T](details: ScalaDataTableTypeDetails[T], scenarioScoped: Boolean): ScalaDataTableTypeDefinition = {
+    details match {
+      case entryDetails@ScalaDataTableEntryTypeDetails(_, _, _) =>
+        if (scenarioScoped) {
+          new ScalaScenarioScopedDataTableEntryDefinition[T](entryDetails)
+        } else {
+          new ScalaGlobalDataTableEntryDefinition[T](entryDetails)
+        }
+      case rowDetails@ScalaDataTableRowTypeDetails(_, _, _) =>
+        if (scenarioScoped) {
+          new ScalaScenarioScopedDataTableRowDefinition[T](rowDetails)
+        } else {
+          new ScalaGlobalDataTableRowDefinition[T](rowDetails)
+        }
+      case rowDetails@ScalaDataTableCellTypeDetails(_, _, _) =>
+        if (scenarioScoped) {
+          new ScalaScenarioScopedDataTableCellDefinition[T](rowDetails)
+        } else {
+          new ScalaGlobalDataTableCellDefinition[T](rowDetails)
+        }
+      case rowDetails@ScalaDataTableTableTypeDetails(_, _, _) =>
+        if (scenarioScoped) {
+          new ScalaScenarioScopedDataTableDefinition[T](rowDetails)
+        } else {
+          new ScalaGlobalDataTableDefinition[T](rowDetails)
+        }
+    }
+  }
+
+}

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

@@ -0,0 +1,14 @@
+package io.cucumber.scala
+
+import scala.reflect.ClassTag
+
+sealed trait ScalaDataTableTypeDetails[T]
+
+case class ScalaDataTableEntryTypeDetails[T](emptyPatterns: Seq[String], body: DataTableEntryDefinitionBody[T], tag: ClassTag[T]) extends ScalaDataTableTypeDetails[T]
+
+case class ScalaDataTableRowTypeDetails[T](emptyPatterns: Seq[String], body: DataTableRowDefinitionBody[T], tag: ClassTag[T]) extends ScalaDataTableTypeDetails[T]
+
+case class ScalaDataTableCellTypeDetails[T](emptyPatterns: Seq[String], body: DataTableCellDefinitionBody[T], tag: ClassTag[T]) extends ScalaDataTableTypeDetails[T]
+
+case class ScalaDataTableTableTypeDetails[T](emptyPatterns: Seq[String], body: DataTableDefinitionBody[T], tag: ClassTag[T]) extends ScalaDataTableTypeDetails[T]
+