#443 - DataTable arguments aren't working with cucumber-scala

scala/gen.scala

@@ -1,13 +1,15 @@
+
 /*
  * Generates the evil looking apply methods in ScalaDsl#StepBody for Function1 to Function22
  */
 for (i <- 1 to 22) {
   val ts = (1 to i).map("T" +).mkString(", ")
   val f = "(" + ts + ") => Any"
-  val pf = "{ case List(" + (1 to i).map("a" +).mkString(", ") + ") => f(" + (1 to i).map(n => "t" + n + "(a" + n + ")").mkString(", ") + ") }"
   val p1 = "def apply[" + ts + "](f: " + f + ")"
-  val p2 = "(implicit " + (1 to i).map(n => "m" + n + ":Manifest[T" + n + "], t" + n + ":Transformation[T" + n + "]").mkString(", ") + ")"
-  val doHandle = "doHandle(List(" + (1 to i).map("m" +).mkString(", ") + "))" + pf
+  val p2 = "(implicit " + (1 to i).map(n => "m" + n + ":Manifest[T" + n + "]").mkString(", ") + ")"
+  val register = "\n  register(List(" + (1 to i).map("m" +).mkString(", ") + ")) {\n"
+  val pf = "    case List(" + (1 to i).map("a" + _ + ":AnyRef").mkString(", ") + ") => \n      f(" + (1 to i).map(n => "a" + n + ".asInstanceOf[T" + n + "]").mkString(",\n        ") + ")"
+  val closeRegister = "\n  }\n}"
 
-  println(p1 + p2 + " = " + doHandle)
+  println(p1 + p2 + " = { " + register + pf + closeRegister + "\n")
 }

scala/src/main/scala/cucumber/runtime/scala/ScalaHookDefinition.scala

@@ -7,7 +7,10 @@ import _root_.cucumber.api.Scenario
 import _root_.cucumber.runtime.HookDefinition
 import collection.JavaConverters._
 
-class ScalaHookDefinition(f:Scenario => Unit, order:Int, tags:Seq[String]) extends HookDefinition {
+class ScalaHookDefinition(f:Scenario => Unit,
+                          order:Int,
+                          tags:Seq[String]) extends HookDefinition {
+
   val tagExpression = new TagExpression(tags.asJava)
 
   def getLocation(detail: Boolean) = "TODO: Implement getLocation in similar fashion to ScalaStepDefinition"

scala/src/main/scala/cucumber/runtime/scala/ScalaStepDefinition.scala

@@ -8,25 +8,77 @@ import _root_.cucumber.runtime.StepDefinition
 import _root_.cucumber.runtime.JdkPatternArgumentMatcher
 import _root_.cucumber.runtime.ParameterInfo
 import collection.JavaConversions._
+import cucumber.api.Transform
 
-class ScalaStepDefinition(frame:StackTraceElement, name:String, pattern:String, parameterInfos:List[Class[_]], f:List[Any] => Any) extends StepDefinition {
+/**
+ * Implementation of step definition for scala.
+ *
+ * @param frame Representation of a stack frame containing information about the context in which a
+ *              step was defined. Allows retrospective queries about the definition of a step.
+ *
+ * @param name The name of the step definition class, e.g. cucumber.runtime.scala.test.CukesStepDefinitions
+ *
+ * @param pattern The regex matcher that defines the cucumber step, e.g. /I eat (.*) cukes$/
 
+ * @param parameterInfos
+ *
+ * @param f Function body of a step definition. This is what actually runs the code within the step def.
+ */
+class ScalaStepDefinition(frame:StackTraceElement,
+                          name:String,
+                          pattern:String,
+                          parameterInfos:List[Class[_]],
+                          f:List[Any] => Any) extends StepDefinition {
+
+  /**
+   * Compiled pattern matcher for the cucumber step regex.
+   */
   private val argumentMatcher = new JdkPatternArgumentMatcher(Pattern.compile(pattern))
 
+  /**
+   * Returns a list of arguments. Return null if the step definition
+   * doesn't match at all. Return an empty List if it matches with 0 arguments
+   * and bigger sizes if it matches several.
+   */
   def matchedArguments(step: Step) = argumentMatcher.argumentsFrom(step.getName)
 
+  /**
+   * The source line where the step definition is defined.
+   * Example: foo/bar/Zap.brainfuck:42
+   *
+   * @param detail true if extra detailed location information should be included.
+   */
   def getLocation(detail: Boolean) = frame.getFileName + ":" + frame.getLineNumber
 
+  /**
+   * How many declared parameters this stepdefinition has. Returns null if unknown.
+   */
   def getParameterCount() = parameterInfos.size()
 
-  // TODO: get rid of Transform.scala and leave transformation to be done by core. The correct implementation is commented out
-  // below until this is fixed.
-  // def getParameterType(index: Int, javaType: Type) = new ParameterInfo(parameterInfos.get(index), null)
-  def getParameterType(index: Int, javaType: Type) = new ParameterInfo(classOf[String], null, null, null)
+  /**
+   * The parameter type at index n. A hint about the raw parameter type is passed to make
+   * it easier for the implementation to make a guess based on runtime information.
+   * As Scala is a statically typed language, the javaType parameter is ignored
+   */
+  def getParameterType(index: Int, javaType: Type) = {
+    new ParameterInfo(parameterInfos.get(index), null, null, null)
+  }
 
+  /**
+   * Invokes the step definition. The method should raise a Throwable
+   * if the invocation fails, which will cause the step to fail.
+   */
   def execute(i18n: I18n, args: Array[AnyRef]) { f(args.toList) }
 
+  /**
+   * Return true if this matches the location. This is used to filter
+   * stack traces.
+   */
   def isDefinedAt(stackTraceElement: StackTraceElement) = stackTraceElement == frame
 
+  /**
+   * @return the pattern associated with this instance. Used for error reporting only.
+   */
   def getPattern = pattern
+
 }

scala/src/test/resources/cucumber/runtime/scala/test/cukes.feature

@@ -2,4 +2,74 @@ Feature: Cukes
 
   Scenario: in the belly
     Given I have 4 "cukes" in my belly
-    Then I am "happy"
+    Then I am "happy"
+
+  Scenario: Int in the belly
+    Given I have eaten an int 100
+    Then I should have one hundred in my belly
+
+  Scenario: Long in the belly
+    Given I have eaten a long 100
+    Then I should have long one hundred in my belly
+
+  Scenario: String in the belly
+    Given I have eaten "numnumnum"
+    Then I should have numnumnum in my belly
+
+  Scenario: Double in the belly
+    Given I have eaten 1.5 doubles
+    Then I should have one and a half doubles in my belly
+
+  Scenario: Float in the belly
+    Given I have eaten 1.5 floats
+    Then I should have one and a half floats in my belly
+
+  Scenario: Short in the belly
+    Given I have eaten a short 100
+    Then I should have short one hundred in my belly
+
+  Scenario: Byte in the belly
+    Given I have eaten a byte 2
+    Then I should have two byte in my belly
+
+  Scenario: BigDecimal in the belly
+    Given I have eaten 1.5 big decimals
+    Then I should have one and a half big decimals in my belly
+
+  Scenario: BigInt in the belly
+    Given I have eaten 10 big int
+    Then I should have a ten big int in my belly
+
+  Scenario: Char in the belly
+    Given I have eaten char 'C'
+    Then I should have character C in my belly
+
+  Scenario: Boolean in the belly
+    Given I have eaten boolean true
+    Then I should have truth in my belly
+
+  Scenario: DataTable in the belly
+    Given I have the following foods :
+      | FOOD   | CALORIES |
+      | cheese |      500 |
+      | burger |     1000 |
+      | fries  |      750 |
+    Then I am "definitely happy"
+    And have eaten 2250.0 calories today
+
+  Scenario: DataTable with args in the belly
+    Given I have a table the sum of all rows should be 400 :
+      | ROW |
+      |  20 |
+      |  80 |
+      | 300 |
+
+  Scenario: Argh! a snake - to be custom mapped
+    Given I see in the distance ... =====>
+    Then I have a snake of length 6 moving east
+    And I see in the distance ... <====================
+    Then I have a snake of length 21 moving west
+
+  Scenario: Custom object with string constructor
+    Given I have a person Bob
+    Then he should say "Hello, I'm Bob!"

scala/src/test/scala/cucumber/api/scala/ScalaDslTest.scala

@@ -5,8 +5,6 @@ import Assert._
 import _root_.gherkin.I18n
 import _root_.gherkin.formatter.model.Tag
 import collection.JavaConverters._
-
-import _root_.cucumber.runtime.scala.Transform
 import cucumber.api.Scenario
 
 class ScalaDslTest {
@@ -127,7 +125,7 @@ class ScalaDslTest {
 
     assertEquals(1, Dummy.stepDefinitions.size)
     val step = Dummy.stepDefinitions.head
-    assertEquals("ScalaDslTest.scala:123", step.getLocation(true)) // be careful with formatting or this test will break
+    assertEquals("ScalaDslTest.scala:121", step.getLocation(true)) // be careful with formatting or this test will break
     assertEquals("x", step.getPattern)
     step.execute(new I18n("en"), Array())
     assertTrue(called)
@@ -147,27 +145,9 @@ class ScalaDslTest {
 
     assertEquals(1, Dummy.stepDefinitions.size)
     val step = Dummy.stepDefinitions(0)
-    step.execute(new I18n("en"), Array("5", "green"))
+    step.execute(new I18n("en"), Array(new java.lang.Integer(5), "green"))
     assertEquals(5, thenumber)
     assertEquals("green", thecolour)
   }
 
-  @Test
-  def transformation {
-    case class Person(name:String)
-
-    var person:Person = null
-
-    object Dummy extends ScalaDsl with EN {
-
-      implicit val transformPerson = Transform(Person(_))
-
-      Given("Person (\\s+)"){ p:Person =>
-        person = p
-      }
-    }
-
-    Dummy.stepDefinitions(0).execute(new I18n("en"), Array("Aslak"))
-    assertEquals(Person("Aslak"), person)
-  }
 }

scala/src/test/scala/cucumber/runtime/scala/model/Person.scala

@@ -0,0 +1,13 @@
+package cucumber.runtime.scala.model
+
+/**
+ * Test model for a "Person"
+ * @param name of person
+ */
+case class Person(name:String) {
+
+  def hello = {
+    "Hello, I'm " + name + "!"
+  }
+
+}

scala/src/test/scala/cucumber/runtime/scala/model/Snake.scala

@@ -0,0 +1,13 @@
+package cucumber.runtime.scala.model
+
+import cucumber.runtime.scala.transform.SnakeConverter
+
+/**
+ * Test model "Snake" to exercise the custom mapper functionality
+ * @param length of the snake in characters
+ * @param direction in which snake is moving 'west, 'east, etc
+ */
+@cucumber.deps.com.thoughtworks.xstream.annotations.XStreamConverter(classOf[SnakeConverter])
+case class Snake(length:Int, direction:Symbol) {
+
+}