Merge branch '2020.1' into development

 Conflicts:
	cucumber-scala/src/main/resources/META-INF/plugin.xml

Author: vbmacher

.travis.yml

@@ -1,26 +1,23 @@
 ext.versions = [
         scala: '2.12',
         scalaFull: '2.12.11',
-        cucumber: '193.6494.1',
-        gherkin: '193.6911.14',
-        idea: '2019.3.4',
-        scalaPlugin: '2019.3.27',
+        cucumber: '201.6668.60',
+        gherkin: '201.6668.60',
+        idea: '2020.1',
+        scalaPlugin: '2020.1.27',
 ]
 
 ext.libs = [
         jUnit            : 'junit:junit:4.13',
         scala            : "org.scala-lang:scala-library:${versions.scalaFull}",
-        cucumberScala    : "info.cukes:cucumber-scala_${versions.scala}:1.2.6",
+        cucumberScala    : "io.cucumber:cucumber-scala_${versions.scala}:4.7.1",
         cucumberJUnit    : 'io.cucumber:cucumber-junit:5.6.0'
 ]
 
 subprojects {
 
     repositories {
         mavenCentral()
-        maven {
-            url "https://oss.sonatype.org/content/repositories/snapshots/"
-        }
         maven {
             url 'https://dl.bintray.com/jetbrains/intellij-plugin-service'
         }

build.gradle

@@ -5,7 +5,6 @@ plugins {
 
 group 'com.github.danielwegener'
 version "${versions.idea}"
-sourceCompatibility = 1.8
 
 dependencies {
   compileOnly libs.scala

cucumber-scala/build.gradle

@@ -3,8 +3,8 @@
 <idea-plugin>
     <id>com.github.danielwegener.cucumber-scala</id>
     <name>Cucumber for Scala</name>
-    <version>2019.3.4</version>
-    <vendor email="[email protected]" url="hhttps://github.com/vbmacher">Peter Jakubčo</vendor>
+    <version>2020.1</version>
+    <vendor email="[email protected]" url="https://github.com/vbmacher">Peter Jakubčo</vendor>
 
     <description><![CDATA[
       Enables Reference tracking of glue code when using cucumber-scala DSL.
@@ -34,11 +34,12 @@
       <li>2017.3.1: Release for IntelliJ 2017.3.1 (scala-plugin 2017.3.11)</li>
       <li>2019.1.3: Release for IntelliJ 2019.1.3 (scala-plugin 2019.1.3)</li>
       <li>2019.3.4: Release for IntelliJ 2019.3.4 (scala-plugin 2019.3.27)</li>
+      <li>2020.1: Release for IntelliJ 2020.1 (scala-plugin 2020.1.27)</li>
       </ul>
     ]]>
     </change-notes>
 
-    <idea-version since-build="193" until-build="193.*" />
+    <idea-version since-build="201" until-build="201.*" />
 
     <depends>com.intellij.modules.java</depends>
     <depends>gherkin</depends>

cucumber-scala/src/main/resources/META-INF/plugin.xml

@@ -2,11 +2,11 @@ package com.github.danielwegener.intellij.cucumber.scala
 
 import java.util.{Collection => JavaCollection}
 
+import com.github.danielwegener.intellij.cucumber.scala.CucumberScalaExtension.JavaList
 import com.github.danielwegener.intellij.cucumber.scala.steps.ScalaStepDefinition
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.module.{Module, ModuleUtilCore}
 import com.intellij.openapi.project.Project
-import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.{JavaPsiFacade, PsiElement, PsiFile}
 import org.jetbrains.annotations.NotNull
 import org.jetbrains.plugins.cucumber.psi.GherkinFile
@@ -25,20 +25,21 @@ import scala.util.Try
 
 object CucumberScalaExtension {
   val LOG: Logger = Logger.getInstance(classOf[CucumberScalaExtension])
+
+  type JavaList[T] = java.util.List[T]
 }
 
 class CucumberScalaExtension extends AbstractCucumberExtension {
-
-  val CUCUMBER_RUNTIME_SCALA_STEP_DEF_TRAIT = "cucumber.api.scala.ScalaDsl"
+  private final val CUCUMBER_RUNTIME_SCALA_STEP_DEF_TRAIT = "cucumber.api.scala.ScalaDsl"
 
   override def isStepLikeFile(@NotNull child: PsiElement, @NotNull parent: PsiElement): Boolean = {
     child.isInstanceOf[ScalaFile]
   }
 
   override def isWritableStepLikeFile(@NotNull child: PsiElement, @NotNull parent: PsiElement): Boolean = {
-
     child match {
-      case scalaFile: ScalaFile if Option(scalaFile.getContainingFile).map(_.getVirtualFile).exists(_.isWritable) => true
+      case scalaFile: ScalaFile =>
+        Option(scalaFile.getContainingFile).map(_.getVirtualFile).exists(_.isWritable)
       case _ => false
     }
   }
@@ -47,59 +48,69 @@ class CucumberScalaExtension extends AbstractCucumberExtension {
   override val getStepFileType: BDDFrameworkType = new BDDFrameworkType(ScalaFileType.INSTANCE)
 
   @NotNull
-  override def getStepDefinitionCreator: StepDefinitionCreator = throw new UnsupportedOperationException("You cannot automatically create Steps yet.")
-
-  override def loadStepsFor(featureFile: PsiFile, module: Module): java.util.List[AbstractStepDefinition] = {
+  override def getStepDefinitionCreator: StepDefinitionCreator = {
+    throw new UnsupportedOperationException("You cannot automatically create Steps yet.")
+  }
 
-    val dependenciesScope: GlobalSearchScope = module.getModuleWithDependenciesAndLibrariesScope(true)
+  override def loadStepsFor(featureFile: PsiFile, module: Module): JavaList[AbstractStepDefinition] = {
     val project: Project = featureFile.getProject
 
-    val stepDefs = for {
-      cucumberDslClass <- JavaPsiFacade.getInstance(project).findClasses(CUCUMBER_RUNTIME_SCALA_STEP_DEF_TRAIT, dependenciesScope)
-      scalaDslInheritingClass <- psi.stubs.util.ScalaInheritors.withStableScalaInheritors(cucumberDslClass).collect { case sc: ScClass => sc; case sct: ScTrait => sct }
-      glueCodeClass <- classAndItsInheritors(scalaDslInheritingClass, dependenciesScope)
+    val stepDefinitions = for {
+      glueCodeClass <- findGlueCodeClass(module, project)
       scConstructorBody <- glueCodeClass.extendsBlock.templateBody.toSeq
       outerMethodCall <- scConstructorBody.getChildren.collect { case mc: ScMethodCall => mc }
-    } yield new ScalaStepDefinition(outerMethodCall)
-
-    JavaConverters.seqAsJavaList(stepDefs)
-
-  }
-
-  def classAndItsInheritors(parentOfHierarchy: ScTypeDefinition, scope: GlobalSearchScope): Iterable[ScTypeDefinition] = {
-
-    @tailrec
-    def rec(queue: List[ScTypeDefinition], akku: Set[ScTypeDefinition]): Set[ScTypeDefinition] = {
-      queue match {
-        case Nil => akku
-        case a =>
-          val newChildren = ScalaInheritors.findInheritorObjects(a.head)
-            .collect { case sc: ScClass => sc; case sct: ScTrait => sct }
-            .filterNot(akku.contains _)
-          rec(a.tail ::: newChildren.toList, akku + a.head)
-
-      }
-
-    }
+    } yield ScalaStepDefinition(outerMethodCall)
 
-    rec(List(parentOfHierarchy), Set.empty)
+    JavaConverters.seqAsJavaList(stepDefinitions)
   }
 
   override def getStepDefinitionContainers(featureFile: GherkinFile): JavaCollection[_ <: PsiFile] = {
     val project: Project = featureFile.getProject
     val maybeModule = Option(ModuleUtilCore.findModuleForPsiElement(featureFile))
 
-    val stepDefs = for {
+    val stepFiles = for {
       module <- maybeModule.toSeq
-      searchScope = module.getModuleContentScope
-      globalSearchScope = module.getModuleWithDependenciesAndLibrariesScope(true)
-      cucumberDslClass <- JavaPsiFacade.getInstance(project).findClasses(CUCUMBER_RUNTIME_SCALA_STEP_DEF_TRAIT, globalSearchScope).toSeq
-      scalaDslInheritingClass@(some: ScClass) <- psi.stubs.util.ScalaInheritors.withStableScalaInheritors(cucumberDslClass)
-      glueCodeClass <- classAndItsInheritors(scalaDslInheritingClass, searchScope)
+      glueCodeClass <- findGlueCodeClass(module, project)
       containingFile <- Try(glueCodeClass.getContainingFile).toOption
     } yield containingFile
 
-    JavaConverters.seqAsJavaList(stepDefs)
+    JavaConverters.seqAsJavaList(stepFiles)
+  }
+
+
+  private def findGlueCodeClass(module: Module, project: Project) = {
+    val dependencies = module.getModuleWithDependenciesAndLibrariesScope(true)
+    val psiFacade = JavaPsiFacade.getInstance(project)
+
+    for {
+      cucumberDslClass <- psiFacade.findClasses(CUCUMBER_RUNTIME_SCALA_STEP_DEF_TRAIT, dependencies).toSeq
+      scalaDslInheritingClass@(some: ScClass) <- psi.stubs.util.ScalaInheritors.withStableScalaInheritors(cucumberDslClass)
+      glueCodeClass <- classAndItsInheritors(scalaDslInheritingClass)
+    } yield glueCodeClass
   }
 
+  private def classAndItsInheritors(parent: ScTypeDefinition): Iterable[ScTypeDefinition] = {
+
+    @tailrec
+    def rec(queue: Seq[ScTypeDefinition], accumulator: Set[ScTypeDefinition]): Set[ScTypeDefinition] = {
+      queue match {
+        case Seq() => accumulator
+        case queueHead +: queueTail =>
+
+          val newChildren = ScalaInheritors.findInheritorObjects(queueHead).collect {
+            case sc: ScClass => sc
+            case sct: ScTrait => sct
+          }
+
+          val childrenToExplore = newChildren
+            .map(_.asInstanceOf[ScTypeDefinition])
+            .diff(accumulator)
+            .toSeq
+
+          rec(queueTail ++ childrenToExplore, accumulator + queueHead)
+      }
+    }
+
+    rec(Seq(parent), Set.empty)
+  }
 }

cucumber-scala/src/main/scala/com/github/danielwegener/intellij/cucumber/scala/CucumberScalaExtension.scala

@@ -1,21 +1,26 @@
 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])
+
+  def apply(scMethodCall: ScMethodCall): ScalaStepDefinition = new ScalaStepDefinition(scMethodCall)
 }
 
 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
@@ -30,17 +35,16 @@ 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
     }
-
   }
 }

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

@@ -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/resources/cucumber/examples/scalacalculator/basic_arithmetic.feature

@@ -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)
   }