Upgrade to support 4.0.1 core version (#12)

glibas · web-flow · commit 0fdcbca26580 · 2018-10-25T08:17:57.000+01:00
diff --git a/examples/pom.xml b/examples/pom.xml
@@ -4,7 +4,7 @@
     <parent>
         <groupId>io.cucumber</groupId>
         <artifactId>cucumber-jvm-scala</artifactId>
-        <version>2.4.0-SNAPSHOT</version>
+        <version>4.0.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>scala-examples</artifactId>
diff --git a/examples/src/test/resources/cucumber/examples/scalacalculator/basic_arithmetic.feature b/examples/src/test/resources/cucumber/examples/scalacalculator/basic_arithmetic.feature
@@ -3,5 +3,5 @@ Feature: Basic Arithmetic
 
   Scenario: Adding
   # Try to change one of the values below to provoke a failure
-    When I add 4 and 5
-    Then the result is 9
+    When I add 4.0 and 5.0
+    Then the result is 9.0
diff --git a/examples/src/test/scala/cucumber/examples/scalacalculator/RpnCalculatorStepDefinitions.scala b/examples/src/test/scala/cucumber/examples/scalacalculator/RpnCalculatorStepDefinitions.scala
@@ -8,13 +8,13 @@ class RpnCalculatorStepDefinitions extends ScalaDsl with EN {
 
   val calc = new RpnCalculator
 
-  When("""^I add (\d+) and (\d+)$"""){ (arg1: Double, arg2: Double) =>
+  When("""I add {double} and {double}"""){ (arg1: Double, arg2: Double) =>
     calc push arg1
     calc push arg2
     calc push "+"
   }
 
-  Then("^the result is (\\d+)$") { expected: Double =>
+  Then("the result is {double}") { expected: Double =>
     assertEquals(expected, calc.value, 0.001)
   }
 
diff --git a/examples/src/test/scala/cucumber/examples/scalacalculator/RunCukesTest.scala b/examples/src/test/scala/cucumber/examples/scalacalculator/RunCukesTest.scala
@@ -1,5 +1,6 @@
 package cucumber.examples.scalacalculator
 
+import cucumber.api.CucumberOptions
 import org.junit.runner.RunWith
 import cucumber.api.junit.Cucumber
 
diff --git a/pom.xml b/pom.xml
@@ -2,7 +2,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>io.cucumber</groupId>
     <artifactId>cucumber-jvm-scala</artifactId>
-    <version>2.4.0-SNAPSHOT</version>
+    <version>4.0.1-SNAPSHOT</version>
     <packaging>pom</packaging>
     <name>Cucumber-JVM: Scala</name>
     <url>http://cucumber.io/</url>
@@ -25,7 +25,7 @@
 
         <scala-maven-plugin.version>3.2.2</scala-maven-plugin.version>
 
-        <cucumber.version>2.4.0</cucumber.version>
+        <cucumber.version>4.0.1</cucumber.version>
         <gherkin.version>5.1.0</gherkin.version>
         <groovy.version>2.4.12</groovy.version>
         <junit.version>4.12</junit.version>
diff --git a/scala/pom.xml b/scala/pom.xml
@@ -4,7 +4,7 @@
     <parent>
         <groupId>io.cucumber</groupId>
         <artifactId>cucumber-jvm-scala</artifactId>
-        <version>2.4.0-SNAPSHOT</version>
+        <version>4.0.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>cucumber-scala-aggregator</artifactId>
diff --git a/scala/scala_2.11/pom.xml b/scala/scala_2.11/pom.xml
@@ -4,7 +4,7 @@
     <parent>
         <groupId>io.cucumber</groupId>
         <artifactId>cucumber-scala-aggregator</artifactId>
-        <version>2.4.0-SNAPSHOT</version>
+        <version>4.0.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>cucumber-scala_2.11</artifactId>
diff --git a/scala/scala_2.12/pom.xml b/scala/scala_2.12/pom.xml
@@ -4,7 +4,7 @@
     <parent>
         <groupId>io.cucumber</groupId>
         <artifactId>cucumber-scala-aggregator</artifactId>
-        <version>2.4.0-SNAPSHOT</version>
+        <version>4.0.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>cucumber-scala_2.12</artifactId>
diff --git a/scala/sources/src/main/scala/cucumber/api/scala/ScalaDsl.scala b/scala/sources/src/main/scala/cucumber/api/scala/ScalaDsl.scala
@@ -5,6 +5,7 @@ import java.lang.reflect.{ParameterizedType, Type}
 import cucumber.api.Scenario
 import cucumber.runtime.{HookDefinition, StepDefinition}
 import cucumber.runtime.scala.{ScalaHookDefinition, ScalaStepDefinition}
+import io.cucumber.stepexpression.TypeRegistry
 
 import scala.collection.mutable.ArrayBuffer
 
@@ -16,13 +17,21 @@ trait ScalaDsl {
   self =>
   import scala.language.implicitConversions
 
-
-  private[cucumber] val stepDefinitions = new ArrayBuffer[StepDefinition]
+  private val stepDefinitions = new ArrayBuffer[StepDefinition]
 
   private[cucumber] val beforeHooks = new ArrayBuffer[HookDefinition]
 
+  private[cucumber] val beforeStepHooks = new ArrayBuffer[HookDefinition]
+
   private[cucumber] val afterHooks = new ArrayBuffer[HookDefinition]
 
+  private[cucumber] val afterStepHooks = new ArrayBuffer[HookDefinition]
+
+  private[cucumber] def getStepDefs(typeRegistry: TypeRegistry): ArrayBuffer[StepDefinition]={
+    stepDefinitions.foreach(d=>d.asInstanceOf[ScalaStepDefinition].typeRegistry = typeRegistry)
+    stepDefinitions
+  }
+
   def Before(f: Scenario => Unit) {
     Before()(f)
   }
@@ -35,6 +44,18 @@ trait ScalaDsl {
     beforeHooks += new ScalaHookDefinition(f, order, tags)
   }
 
+  def BeforeStep(f: Scenario => Unit) {
+    BeforeStep()(f)
+  }
+
+  def BeforeStep(tags: String*)(f: Scenario => Unit) {
+    BeforeStep(Int.MaxValue, tags: _*)(f)
+  }
+
+  def BeforeStep(order: Int, tags: String*)(f: Scenario => Unit) {
+    beforeStepHooks += new ScalaHookDefinition(f, order, tags)
+  }
+
   def After(f: Scenario => Unit) {
     After()(f)
   }
@@ -47,6 +68,19 @@ trait ScalaDsl {
     afterHooks += new ScalaHookDefinition(f, order, tags)
   }
 
+  def AfterStep(f: Scenario => Unit) {
+    AfterStep()(f)
+  }
+
+  def AfterStep(tags: String*)(f: Scenario => Unit) {
+    AfterStep(Int.MaxValue, tags: _*)(f)
+  }
+
+  def AfterStep(order: Int, tags: String*)(f: Scenario => Unit) {
+    afterStepHooks += new ScalaHookDefinition(f, order, tags)
+  }
+
+
   final class Step(name: String) {
     def apply(regex: String): StepBody = new StepBody(name, regex)
   }
diff --git a/scala/sources/src/main/scala/cucumber/runtime/scala/ScalaBackend.scala b/scala/sources/src/main/scala/cucumber/runtime/scala/ScalaBackend.scala
@@ -1,8 +1,10 @@
 package cucumber.runtime.scala
 
 import java.util.{List => JList}
+
 import gherkin.pickles.PickleStep
 import java.lang.reflect.Modifier
+
 import cucumber.runtime.snippets.SnippetGenerator
 import cucumber.runtime.snippets.FunctionNameGenerator
 import cucumber.api.scala.ScalaDsl
@@ -11,20 +13,26 @@ import cucumber.runtime.io.ResourceLoaderClassFinder
 import cucumber.runtime.io.ResourceLoader
 import cucumber.runtime.io.MultiLoader
 import cucumber.runtime.Backend
-import cucumber.runtime.UnreportedStepExecutor
 import cucumber.runtime.Glue
+import io.cucumber.stepexpression.TypeRegistry
+
 import scala.collection.JavaConverters._
 
-class ScalaBackend(resourceLoader:ResourceLoader) extends Backend {
-  private var snippetGenerator = new SnippetGenerator(new ScalaSnippetGenerator())
+class ScalaBackend(resourceLoader:ResourceLoader, typeRegistry: TypeRegistry) extends Backend {
+  private val snippetGenerator = new SnippetGenerator(new ScalaSnippetGenerator(), typeRegistry.parameterTypeRegistry())
   private var instances:Seq[ScalaDsl] = Nil
 
-  def getStepDefinitions = instances.flatMap(_.stepDefinitions)
+  
+  def getStepDefinitions = instances.flatMap(_.getStepDefs(typeRegistry))
 
   def getBeforeHooks = instances.flatMap(_.beforeHooks)
 
   def getAfterHooks = instances.flatMap(_.afterHooks)
 
+  def getAfterStepHooks = instances.flatMap(_.afterStepHooks)
+
+  def getBeforeStepHooks = instances.flatMap(_.beforeStepHooks)
+
   def disposeWorld() {
     instances = Nil
   }
@@ -61,14 +69,15 @@ class ScalaBackend(resourceLoader:ResourceLoader) extends Backend {
       instField.setAccessible(true)
       instField.get(null).asInstanceOf[ScalaDsl]
     }
-    val clsInstances = (clsClasses map {_.newInstance()})
+    val clsInstances = clsClasses map {_.newInstance()}
 
     instances = objInstances ++ clsInstances
 
     getStepDefinitions map {glue.addStepDefinition(_)}
     getBeforeHooks map {glue.addBeforeHook(_)}
     getAfterHooks map  {glue.addAfterHook(_)}
+    getAfterStepHooks map  {glue.addAfterStepHook(_)}
+    getBeforeStepHooks map  {glue.addBeforeStepHook(_)}
   }
 
-  def setUnreportedStepExecutor(executor:UnreportedStepExecutor) {}
 }
diff --git a/scala/sources/src/main/scala/cucumber/runtime/scala/ScalaHookDefinition.scala b/scala/sources/src/main/scala/cucumber/runtime/scala/ScalaHookDefinition.scala
@@ -2,9 +2,11 @@ package cucumber.runtime.scala
 
 import gherkin.pickles.PickleTag
 import java.util.Collection
+
 import cucumber.api.Scenario
 import cucumber.runtime.HookDefinition
-import cucumber.runtime.TagPredicate
+import cucumber.runtime.filter.TagPredicate
+
 import scala.collection.JavaConverters._
 
 class ScalaHookDefinition(f:Scenario => Unit,
diff --git a/scala/sources/src/main/scala/cucumber/runtime/scala/ScalaSnippetGenerator.scala b/scala/sources/src/main/scala/cucumber/runtime/scala/ScalaSnippetGenerator.scala
@@ -1,8 +1,10 @@
 package cucumber.runtime.scala
 
+import java.lang.reflect.Type
+import java.util
+
 import cucumber.runtime.snippets.Snippet
-import gherkin.pickles.PickleStep
-import java.util.List
+
 import collection.JavaConverters._
 
 class ScalaSnippetGenerator extends Snippet {
@@ -15,8 +17,14 @@ class ScalaSnippetGenerator extends Snippet {
 
   def tableHint() = null
 
-  def arguments(argumentTypes: List[Class[_]]) = {
-    val indexed = argumentTypes.asScala.zipWithIndex
+  def namedGroupStart() = null
+
+  def namedGroupEnd() = null
+
+  def escapePattern(pattern:String) = pattern
+
+  override def arguments(map: util.Map[String, Type]): String = {
+    val indexed = map.asScala.zipWithIndex
 
     def name(clazz: Class[_]) =
       if(clazz.isPrimitive){
@@ -26,16 +34,9 @@ class ScalaSnippetGenerator extends Snippet {
         clazz.getSimpleName
 
     val named = indexed.map {
-      case (c, i) => "arg" + i + ":" + name(c)
+      case (c, i) => "arg" + i + ":" + name(c._2.getClass)
     }
 
     named.mkString(", ")
   }
-
-  def namedGroupStart() = null
-
-  def namedGroupEnd() = null
-
-  def escapePattern(pattern:String) = pattern
-
 }
diff --git a/scala/sources/src/main/scala/cucumber/runtime/scala/ScalaStepDefinition.scala b/scala/sources/src/main/scala/cucumber/runtime/scala/ScalaStepDefinition.scala
@@ -1,13 +1,10 @@
 package cucumber.runtime.scala
 
 import java.lang.reflect.Type
-import gherkin.pickles.PickleStep
-import java.util.regex.Pattern
+
 import cucumber.runtime.StepDefinition
-import cucumber.runtime.JdkPatternArgumentMatcher
-import cucumber.runtime.ParameterInfo
-import collection.JavaConversions._
-import cucumber.api.Transform
+import gherkin.pickles.PickleStep
+import io.cucumber.stepexpression._
 
 /**
  * Implementation of step definition for scala.
@@ -29,56 +26,68 @@ class ScalaStepDefinition(frame:StackTraceElement,
                           parameterInfos:Array[Type],
                           f:List[Any] => Any) extends StepDefinition {
 
-  /**
-   * Compiled pattern matcher for the cucumber step regex.
-   */
-  private val argumentMatcher = new JdkPatternArgumentMatcher(Pattern.compile(pattern))
+  private[cucumber] var typeRegistry: TypeRegistry = null
+  private var expression: StepExpression = null
 
   /**
    * 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: PickleStep) = argumentMatcher.argumentsFrom(step.getText)
+  def matchedArguments(step: PickleStep) = {
+     expression = createExpression(pattern, typeRegistry)
+     val argumentMatcher = new ExpressionArgumentMatcher(expression)
+     argumentMatcher.argumentsFrom(step)
+  }
+
+  private def createExpression(expression: String, typeRegistry: TypeRegistry): StepExpression = {
+    if (parameterInfos.isEmpty) new StepExpressionFactory(typeRegistry).createExpression(expression)
+    else {
+      val parameterInfo = parameterInfos(parameterInfos.size - 1)
+      new StepExpressionFactory(typeRegistry).createExpression(expression, parameterInfo, false)
+    }
+  }
 
   /**
    * 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
+  override def getLocation(detail: Boolean) = frame.getFileName + ":" + frame.getLineNumber
 
   /**
    * How many declared parameters this stepdefinition has. Returns null if unknown.
    */
-  def getParameterCount() = parameterInfos.size
+  override def getParameterCount() = parameterInfos.size
 
   /**
    * 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(index), null, null, null)
+    parameterInfos(index)
   }
 
   /**
    * Invokes the step definition. The method should raise a Throwable
    * if the invocation fails, which will cause the step to fail.
    */
-  def execute(language: String, args: Array[AnyRef]) { f(args.toList) }
+  override def execute(args: Array[AnyRef]): Unit = {
+    f(args.toList)
+  }
 
   /**
    * Return true if this matches the location. This is used to filter
    * stack traces.
    */
-  def isDefinedAt(stackTraceElement: StackTraceElement) = stackTraceElement == frame
+  override def isDefinedAt(stackTraceElement: StackTraceElement) = stackTraceElement == frame
 
   /**
    * @return the pattern associated with this instance. Used for error reporting only.
    */
-  def getPattern = pattern
+  override def getPattern = pattern
 
-  def isScenarioScoped = false
+  override def isScenarioScoped = false
 }
diff --git a/scala/sources/src/test/scala/cucumber/api/scala/ScalaDslTest.scala b/scala/sources/src/test/scala/cucumber/api/scala/ScalaDslTest.scala
diff --git a/scala/sources/src/test/scala/cucumber/runtime/scala/model/Snake.scala b/scala/sources/src/test/scala/cucumber/runtime/scala/model/Snake.scala
diff --git a/scala/sources/src/test/scala/cucumber/runtime/scala/test/StepDefs.scala b/scala/sources/src/test/scala/cucumber/runtime/scala/test/StepDefs.scala
diff --git a/scala/sources/src/test/scala/cucumber/runtime/scala/test/TypeRegistryConfiguration.scala b/scala/sources/src/test/scala/cucumber/runtime/scala/test/TypeRegistryConfiguration.scala
diff --git a/scala/sources/src/test/scala/cucumber/runtime/scala/transform/SnakeConverter.scala b/scala/sources/src/test/scala/cucumber/runtime/scala/transform/SnakeConverter.scala

Original file line number	Diff line number	Diff line change
`@@ -8,13 +8,13 @@ class RpnCalculatorStepDefinitions extends ScalaDsl with EN {`
`8`	`8`
`9`	`9`	`val calc = new RpnCalculator`
`10`	`10`
`11`		`- When("""^I add (\d+) and (\d+)$"""){ (arg1: Double, arg2: Double) =>`
	`11`	`+ When("""I add {double} and {double}"""){ (arg1: Double, arg2: Double) =>`
`12`	`12`	`calc push arg1`
`13`	`13`	`calc push arg2`
`14`	`14`	`calc push "+"`
`15`	`15`	`}`
`16`	`16`
`17`		`- Then("^the result is (\\d+)$") { expected: Double =>`
	`17`	`+ Then("the result is {double}") { expected: Double =>`
`18`	`18`	`assertEquals(expected, calc.value, 0.001)`
`19`	`19`	`}`
`20`	`20`