[#17] Support constant expressions in step definitions

Author: vbmacher

cucumber-scala/src/main/scala/com/github/danielwegener/intellij/cucumber/scala/steps/ScalaStepDefinition.scala

@@ -1,14 +1,15 @@
 package com.github.danielwegener.intellij.cucumber.scala.steps
 
-import org.jetbrains.plugins.cucumber.steps.AbstractStepDefinition
-import org.jetbrains.plugins.scala.lang.psi.api.expr.ScMethodCall
-import org.jetbrains.annotations.Nullable
-import com.intellij.psi.PsiElement
-import org.jetbrains.plugins.scala.lang.psi.api.base.ScLiteral
 import java.util
-import com.intellij.openapi.diagnostic.Logger
 import java.util.Collections
 
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.psi.PsiElement
+import org.jetbrains.annotations.Nullable
+import org.jetbrains.plugins.cucumber.steps.AbstractStepDefinition
+import org.jetbrains.plugins.scala.lang.psi.api.expr.ScMethodCall
+import org.jetbrains.plugins.scala.lang.psi.util.ScalaConstantExpressionEvaluator
+
 object ScalaStepDefinition {
   val LOG: Logger = Logger.getInstance(classOf[ScalaStepDefinition])
 
@@ -18,6 +19,8 @@ object ScalaStepDefinition {
 class ScalaStepDefinition(scMethod: ScMethodCall) extends AbstractStepDefinition(scMethod) {
   import ScalaStepDefinition._
 
+  private final val evaluator = new ScalaConstantExpressionEvaluator()
+
   override def getVariableNames: util.List[String] = {
     val r = for {
       // WHEN("""regexp""") { (arg0:Int, arg1:String) <-- we want to match these
@@ -32,15 +35,15 @@ class ScalaStepDefinition(scMethod: ScMethodCall) extends AbstractStepDefinition
 
   @Nullable
   override def getCucumberRegexFromElement(element: PsiElement): String = {
-
     element match {
       case mc: ScMethodCall =>
-        val x = for {
+        val literals = for {
           innerMethodCall <- Some(mc.getEffectiveInvokedExpr).toSeq.collect { case some: ScMethodCall => some }
-          literalParameter @ (someOther: ScLiteral) <- innerMethodCall.args.exprs
-          if literalParameter.isString
-        } yield literalParameter.getValue.toString
-        x.headOption.orNull
+          expression <- innerMethodCall.args.exprs
+          literal <- Option(evaluator.computeConstantExpression(expression, throwExceptionOnOverflow = false)).toSeq
+        } yield literal.toString
+
+        literals.headOption.orNull
       case _ => null
     }
   }

example/src/test/resources/cucumber/examples/scalacalculator/basic_arithmetic.feature

@@ -2,7 +2,14 @@
 Feature: Basic Arithmetic
 
   Scenario: Adding
-  # Try to change one of the values below to provoke a failure
+    # Try to change one of the values below to provoke a failure
     When I add 4 and 5
     Then the result is 9
 
+  Scenario: Subtracting
+    When I sub 4 and 5
+    Then the result is -1
+
+  Scenario: Dividing
+    When I div 10 by 2
+    Then the result is 5

example/src/test/scala/RpnCalculatorStepDefinitions.scala

@@ -1,7 +1,5 @@
-
-
 import cucumber.api.Scenario
-import cucumber.api.scala.{ScalaDsl, EN}
+import cucumber.api.scala.EN
 import org.junit.Assert._
 
 class RpnCalculatorStepDefinitions extends ScalaDslIndirection with EN {
@@ -14,7 +12,20 @@ class RpnCalculatorStepDefinitions extends ScalaDslIndirection with EN {
     calc push "+"
   }
 
-  Then("^the result is (\\d+)$") { expected: Double =>
+  When("I sub (\\d+)" + " and " + "(\\d+)") {
+    (arg1: Double, arg2: Double) =>
+      calc push arg1
+      calc push arg2
+      calc push "-"
+  }
+
+  When("I div " + (5 + 5) + " by " + (10 - 8)) {
+    calc push 10.0
+    calc push 2.0
+    calc push "/"
+  }
+
+  Then("^the result is ([+-]?\\d+)$") { expected: Double =>
     assertEquals(expected, calc.value, 0.001)
   }