Merge pull request #100 from cucumber/v6.2

Merge new features for v6.2

Author: gaeljw

CHANGELOG.md

@@ -11,6 +11,12 @@ See also the [CHANGELOG](https://github.com/cucumber/cucumber-jvm/blob/master/CH
 
 ### Added
 
+- Add `asScalaRawList[T]`, `asScalaRawMaps[T]` and `asScalaRawLists[T]` on `DataTable` (through `io.cucumber.scala.Implicits`) ([#83](https://github.com/cucumber/cucumber-jvm-scala/issues/83) Gaël Jourdan-Weil)
+- Add new `DataTableType` definitions with optional input values ([#84](https://github.com/cucumber/cucumber-jvm-scala/issues/84) Gaël Jourdan-Weil)
+  - `DataTableType { (entry: Map[String, Option[String]]) => ... }`
+  - `DataTableType { (row: Seq[Option[String]]) => ... }`
+  - `DataTableType { (cell: Option[String]) => ... }`
+
 ### Changed
 
 - [Core] Update `cucumber-core` dependency to [6.2.0](https://github.com/cucumber/cucumber-jvm/blob/main/CHANGELOG.md)

docs/datatables.md

@@ -8,6 +8,8 @@ Cucumber Scala support DataTables with either:
 
 See below the exhaustive list of possible mappings.
 
+_Note: you can use [transformers](transformers.md) to map DataTables to custom types._ 
+
 ## As Map of Map
 
 ```gherkin

docs/transformers.md

@@ -87,7 +87,7 @@ This can be achieved in different ways:
 - transform cells content to any type
 
 Note that DataTables in Gherkin can not represent `null` or the empty string unambiguously.
-Cucumber will interpret empty cells as `null`.
+Cucumber will interpret empty cells as `None` or `null`.
 But you can use a replacement to represent empty strings.
 See below.
 
@@ -99,8 +99,8 @@ For instance, the following transformer can be defined:
 ```scala
 case class Author(name: String, surname: String, famousBook: String)
 
-DataTableType { entry: Map[String, String] =>
-  Author(entry("name"), entry("surname"), entry("famousBook"))
+DataTableType { entry: Map[String, Option[String]] => // Or Map[String, String]
+  Author(entry("name").getOrElse("NoValue"), entry("surname").getOrElse("NoValue"), entry("famousBook").getOrElse("NoValue"))
 }
 ```
 
@@ -113,13 +113,15 @@ Given the following authors
 ```
 
 ```scala
-Given("the following authors") { (authors: java.util.List[Author]) =>
-  // Do something
-}
+import io.cucumber.scala.Implicits._
 
-// Or using DataTable
 Given("the following authors") { (table: DataTable) =>
-  val authors = table.asList[Author](classOf[Author])
+  val authors = table.asScalaRawList[Author]
+}
+
+// Or using Java type
+Given("the following authors") { (authors: java.util.List[Author]) =>
+  // Do something
 }
 ```
 
@@ -129,8 +131,8 @@ For instance, the following transformer can be defined:
 ```scala
 case class Author(name: String, surname: String, famousBook: String)
 
-DataTableType { row: Seq[String] =>
-  Author(row(0), row(1), row(2))
+DataTableType { row: Seq[Option[String]] => // Or Seq[String]
+  Author(row(0).getOrElse("NoValue"), row(1).getOrElse("NoValue"), row(2).getOrElse("NoValue"))
 }
 ```
 
@@ -142,20 +144,24 @@ Given the following authors
 ```
 
 ```scala
-Given("the following authors") { (authors: java.util.List[Author]) =>
-  // Do something
-}
+import io.cucumber.scala.Implicits._
 
-// Or using DataTable
 Given("the following authors") { (table: DataTable) =>
-  val authors = table.asList[Author](classOf[Author])
+  val authors = table.asScalaRawList[Author]
+}
+
+// Or using Java types
+Given("the following authors") { (authors: java.util.List[Author]) =>
+  // Do something
 }
 ```
 
 ### DataTable
 
 For instance, the following transformer can be defined:
 ```scala
+import io.cucumber.scala.Implicits._
+
 case class Author(name: String, surname: String, famousBook: String)
 case class GroupOfAuthor(authors: Seq[Author])
 
@@ -191,8 +197,8 @@ For instance, the following transformer can be defined:
 ```scala
 case class RichCell(content: String)
 
-DataTableType { cell: String =>
-  RichCell(cell)
+DataTableType { cell: Option[String] => // Or String
+  RichCell(cell.getOrElse("NoValue"))
 }
 ```
 
@@ -204,13 +210,15 @@ Given the following authors
 ```
 
 ```scala
-Given("the following authors") { (authors: java.util.List[java.util.List[RichCell]]) =>
-  // Do something
-}
+import io.cucumber.scala.Implicits._
 
-// Or using DataTable
 Given("the following authors") { (table: DataTable) =>
-  val authors = table.asLists[RichCell](classOf[RichCell]))
+  val authors = table.asScalaRawLists[RichCell]
+}
+
+// Or using Java types
+Given("the following authors") { (authors: java.util.List[java.util.List[RichCell]]) =>
+  // Do something
 }
 ```
 
@@ -223,19 +231,21 @@ Given the following authors
 ```
 
 ```scala
-Given("the following authors") { (authors: java.util.List[java.util.Map[String, RichCell]]) =>
-  // Do something
-}
+import io.cucumber.scala.Implicits._
 
-// Or using DataTable
 Given("the following authors") { (table: DataTable) =>
-  val authors = table.asMaps[String, RichCell](classOf[String], classOf[RichCell])
+  val authors = table.asScalaRawMaps[String, RichCell]
+}
+
+// Or with Java Types
+Given("the following authors") { (authors: java.util.List[java.util.Map[String, RichCell]]) =>
+  // Do something
 }
 ```
 
 ### Empty values
 
-By default empty values in DataTable are treated as `null` by Cucumber.
+By default empty values in DataTable are treated as `None` or `null` by Cucumber.
 If you need to have empty values, you can define a replacement like `[empty]` that will be automatically replaced to empty when parsing DataTable.
 
 To do so, you can add a parameter to a `DataTableType` definition.
@@ -244,7 +254,7 @@ For instance, with the following definition:
 ```scala
 case class Author(name: String, surname: String, famousBook: String)
 
-DataTableType("[empty]") { (entry: Map[String, String]) =>
+DataTableType("[empty]") { (entry: Map[String, String]) => // Or Map[String, Option[String]]
   Author(entry("name"), entry("surname"), entry("famousBook"))
 }
 ```
@@ -296,13 +306,15 @@ DefaultDataTableEntryTransformer("[empty]") { (fromValue: Map[String, String], t
 
 Will be used to convert with such step definitions:
 ```scala
-Given("A step with a datatable") { (rows: java.util.List[SomeType]) =>
-  // Do something
-}
+import io.cucumber.scala.Implicits._
 
-// Or DataTable
 Given("A step with a datatable") { (dataTable: DataTable) =>
-  val table = dataTable.asList[SomeType](classOf[SomeType])
+  val table = dataTable.asScalaRawList[SomeType]
+}
+
+// Or with Java types
+Given("A step with a datatable") { (rows: java.util.List[SomeType]) =>
+  // Do something
 }
 ```
 
@@ -319,12 +331,14 @@ DefaultDataTableCellTransformer("[empty]") { (fromValue: String, toValueType: ja
 
 Will be used to convert with such step definitions:
 ```scala
-Given("A step with a datatable") { (rows: java.util.List[java.util.List[SomeType]]) =>
-  // Do something
-}
+import io.cucumber.scala.Implicits._
 
-// Or DataTable
 Given("A step with a datatable") { (dataTable: DataTable) =>
-  val table = dataTable.asLists[SomeType](classOf[SomeType])
+  val table = dataTable.asScalaRawLists[SomeType]
+}
+
+// Or with Java Types
+Given("A step with a datatable") { (rows: java.util.List[java.util.List[SomeType]]) =>
+  // Do something
 }
 ```

scala/scala_2.11/src/main/scala/io/cucumber/scala/package.scala

@@ -21,16 +21,25 @@ package object scala {
     override def transform(entry: Map[String, String]): T = f.apply(entry)
   }
 
+  implicit def function1AsDataTableOptionalEntryDefinitionBody[T](f: (Map[String, Option[String]]) => T): DataTableOptionalEntryDefinitionBody[T] = new DataTableOptionalEntryDefinitionBody[T] {
+    override def transform(entry: Map[String, Option[String]]): T = f.apply(entry)
+  }
 
   implicit def function1AsDataTableRowDefinitionBody[T](f: (Seq[String]) => T): DataTableRowDefinitionBody[T] = new DataTableRowDefinitionBody[T] {
     override def transform(row: Seq[String]): T = f.apply(row)
   }
 
+  implicit def function1AsDataTableOptionalRowDefinitionBody[T](f: (Seq[Option[String]]) => T): DataTableOptionalRowDefinitionBody[T] = new DataTableOptionalRowDefinitionBody[T] {
+    override def transform(row: Seq[Option[String]]): T = f.apply(row)
+  }
 
   implicit def function1AsDataTableCellDefinitionBody[T](f: (String) => T): DataTableCellDefinitionBody[T] = new DataTableCellDefinitionBody[T] {
     override def transform(cell: String): T = f.apply(cell)
   }
 
+  implicit def function1AsDataTableOptionalCellDefinitionBody[T](f: (Option[String]) => T): DataTableOptionalCellDefinitionBody[T] = new DataTableOptionalCellDefinitionBody[T] {
+    override def transform(cell: Option[String]): T = f.apply(cell)
+  }
 
   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/DataTableDefinitionBody.scala

@@ -8,18 +8,36 @@ trait DataTableEntryDefinitionBody[T] {
 
 }
 
+trait DataTableOptionalEntryDefinitionBody[T] {
+
+  def transform(entry: Map[String, Option[String]]): T
+
+}
+
 trait DataTableRowDefinitionBody[T] {
 
   def transform(row: Seq[String]): T
 
 }
 
+trait DataTableOptionalRowDefinitionBody[T] {
+
+  def transform(row: Seq[Option[String]]): T
+
+}
+
 trait DataTableCellDefinitionBody[T] {
 
   def transform(cell: String): T
 
 }
 
+trait DataTableOptionalCellDefinitionBody[T] {
+
+  def transform(cell: Option[String]): T
+
+}
+
 trait DataTableDefinitionBody[T] {
 
   def transform(dataTable: DataTable): T

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

@@ -23,6 +23,8 @@ object Implicits {
      * Provides a view of the DataTable as a sequence of rows, each row being a key-value map where key is the column name.
      * Equivalent of `.asMaps[K,V](classOf[K], classOf[V])` but returned as Scala collection types without `null` values.
      *
+     * See also `asScalaRawMaps[T]` if you don't need `Option`s (for instance if you are using a DataTableType).
+     *
      * @tparam K key type
      * @tparam V value type
      * @return sequence of rows
@@ -42,6 +44,23 @@ object Implicits {
      */
     def asScalaMaps: Seq[Map[String, Option[String]]] = asScalaMaps[String, String]
 
+    /**
+     * Provides a view of the DataTable as a sequence of rows, each row being a key-value map where key is the column name.
+     * Equivalent of `.asMaps[K,V](classOf[K], classOf[V])` but returned as Scala collection types.
+     *
+     * See also `asScalaMaps[T]`.
+     *
+     * @tparam K key type
+     * @tparam V value type
+     * @return sequence of rows
+     */
+    def asScalaRawMaps[K, V](implicit evK: ClassTag[K], evV: ClassTag[V]): Seq[Map[K, V]] = {
+      table.asMaps[K, V](evK.runtimeClass, evV.runtimeClass)
+        .asScala
+        .map(_.asScala.toMap)
+        .toSeq
+    }
+
     /**
      * Provides a view of the DataTable as a key-value map where key are the first column values.
      * Equivalent of `.asMap[K,V](classOf[K],classOf[V])` but returned as Scala collection types without `null` values.
@@ -61,6 +80,8 @@ object Implicits {
      * Provides a view of the DataTable as a matrix.
      * Equivalent of `.asLists[T](classOf[T])` but returned as Scala collection types without `null` values.
      *
+     * See also `asScalaRawLists[T]` if you don't need `Option`s (for instance if you are using a DataTableType).
+     *
      * @tparam T cell type
      * @return matrix
      */
@@ -79,10 +100,28 @@ object Implicits {
      */
     def asScalaLists: Seq[Seq[Option[String]]] = asScalaLists[String]
 
+    /**
+     * Provides a view of the DataTable as a matrix.
+     * Equivalent of `.asLists[T](classOf[T])` but returned as Scala collection types.
+     *
+     * See also `asScalaLists[T]`
+     *
+     * @tparam T cell type
+     * @return matrix
+     */
+    def asScalaRawLists[T](implicit ev: ClassTag[T]): Seq[Seq[T]] = {
+      table.asLists[T](ev.runtimeClass)
+        .asScala
+        .map(_.asScala.toSeq)
+        .toSeq
+    }
+
     /**
      * Provides a view of the DataTable as a simple list of values.
      * Equivalent of `.asList[T](classOf[T])` but returned as Scala collection types without `null` values.
      *
+     * See also `asScalaRawList[T]` if you don't need `Option`s (for instance if you are using a DataTableType).
+     *
      * @tparam T cell type
      * @return list of values
      */
@@ -101,6 +140,21 @@ object Implicits {
      */
     def asScalaList: Seq[Option[String]] = asScalaList[String]
 
+    /**
+     * Provides a view of the DataTable as a simple list of values.
+     * Equivalent of `.asList[T](classOf[T])` but returned as Scala collection types.
+     *
+     * See also `asScalaList[T]`.
+     *
+     * @tparam T cell/row type
+     * @return list of values
+     */
+    def asScalaRawList[T](implicit ev: ClassTag[T]): Seq[T] = {
+      table.asList[T](ev.runtimeClass)
+        .asScala
+        .toSeq
+    }
+
     /**
      * Provides a view of the DataTable as a full table: a key-value map of row where keys are the first column values
      * and each row being itself a key-value map where key is the column name.

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

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