- Upgrade to IDEA 2019.3.2

- Add development instructions for the gradle plugin

Author: danielwegener

README.md

@@ -15,79 +15,17 @@ Enables Reference tracking of glue code when using cucumber-scala DSL.
 # Development
 
 1. `git clone [email protected]:danielwegener/intellij-cucumber-scala.git`
-2. `sbt updateIdea` will download the idea sdk to the SDK folder and all required plugins
-3. Import the project as sbt project into IDEA.
+2. `./gradlew` will download the idea sdk to the SDK folder and all required plugins
+3. Import the project as gradle project into IDEA.
 
-Now you can build this plugin with `sbt package`
-
-> IntelliJ Plugin Development is too hard :/ Please provide a public (maybe non-oss, non-free) repo for Idea artifacts. Or maybe a sbt plugin.
-
-To start an IDE with the plugin installed in the example project just run `sbt "runIdea example"` (_todo: does not work yet_)
-
-
-# Using a run configuration
-(set it to 'single instance only' so it kills the current version when restarting)
-
-This is all reverse engineered (in reality playing a game of spot the difference)
-with the scala plugin run configurations.
-
-https://github.com/JetBrains/intellij-scala/blob/8030aef21f8f726796f7230d5f29669e35ebeec9/.idea/runConfigurations/IDEA.xml#L7
-
-It is quite important that scala library does not get added to the classpath etc. If there are
-problems run the scala plugin by
-
-1. Checkout https://github.com/JetBrains/intellij-scala
-2. Open in Intellij
-3. git checkout idea as that will demangle the run configuration so it can be ran easily
-
-When running a configuration to analyse the output of the run window replace : with new lines
-so it is diffable.
-
-## Main class
-```
-com.intellij.idea.Main
-```
-
-## VM Options (Note this is using build id 181.4445.78)
-``` 
--Xmx800m
--XX:ReservedCodeCacheSize=240m
--XX:+HeapDumpOnOutOfMemoryError
--ea
--Didea.is.internal=true
--Didea.debug.mode=true
--Dapple.laf.useScreenMenuBar=true
--Dplugin.path=target/scala-2.12/intellij-cucumber-scala_2.12-2018.1.0.jar
--Didea.platform.prefix=Idea
--Didea.system.path=idea/system
--Didea.config.path=idea/config
--Didea.plugins.path=idea/181.4445.78/externalPlugins
-```
-
-If system and config outside of extraction directory then it is easier to
-purge when a new version is out. You don't have to go through the whole
-running for the first time wizard.
-
-
-## Use classpath of module
-```
-runner-cucumber-scala-idea
-```
-
-## Optional but useful
-Under run configuration create additional before launch external tool
-1. Name: sbt_package
-2. Program: sbt
-3. Arguments: package
-
-This will mean that a fresh plugin jar is created each time the test community
-edition launches from the run configuration.
+Now you can build this plugin with `./gradlew buildPlugin`.
 
+To start an IDE with the plugin installed in the example project just run `./gradlew runIde`. Import the whole project as gradle project in the sandbox-ide. Wait for indexing to finish. Open `example/src/test/resources/cucumber/examples/scalacalculator/basic_arithmetic.feature`.
+ 
 # Publishing
 
-
-1. Add your credentials to `ideaPublishSettings` in `build.sbt` (make sure to not check them in!)
-2 run `sbt publishPlugin`
+1. Add your publish token to `publishPlugin.token` in `cucumber-scala/build.gradle` (make sure to not check them in!)
+2 run `./gradlew publishPlugin`
 
 # License
 

build.gradle

@@ -1,17 +1,17 @@
 ext.versions = [
         scala: '2.12',
-        scalaFull: '2.12.8',
-        cucumber: '191.7479.7',
-        gherkin: '191.6707.7',
-        idea: '2019.1.3',
-        scalaPlugin: '2019.1.9'
+        scalaFull: '2.12.7',
+        cucumber: '193.5662.7',
+        gherkin: '193.6015.53',
+        idea: '2019.3.2',
+        scalaPlugin: '2019.3.23',
 ]
 
 ext.libs = [
         jUnit            : 'junit:junit:4.12',
         scala            : "org.scala-lang:scala-library:${versions.scalaFull}",
-        scalaTest        : "org.scalatest:scalatest_${versions.scala}:3.0.5",
-        cucumber         : "info.cukes:cucumber-scala_${versions.scala}:1.2.4"
+        cucumberScala    : "info.cukes:cucumber-scala_${versions.scala}:1.2.4",
+        cucumberJUnit    : 'io.cucumber:cucumber-junit:5.1.1'
 ]
 
 subprojects {

cucumber-scala/build.gradle

@@ -1,5 +1,5 @@
 plugins {
-  id "org.jetbrains.intellij" version "0.4.9"
+  id "org.jetbrains.intellij" version "0.4.16"
   id "scala"
 }
 
@@ -8,23 +8,24 @@ version "${versions.idea}"
 sourceCompatibility = 1.8
 
 dependencies {
-  implementation libs.scala
+  compileOnly libs.scala
 }
 
 intellij {
   pluginName 'intellij-cucumber-scala'
-  version "IC-${versions.idea}"
+  version "${versions.idea}"
+  type "IC"
 
   plugins = [
     "cucumber-java:${versions.cucumber}",
     "gherkin:${versions.gherkin}",
+    "java",
     "org.intellij.scala:${versions.scalaPlugin}"
   ]
   updateSinceUntilBuild false
 }
 
 publishPlugin {
-  username ''
-  password ''
-  channels ''
+  token ''
+  //channels 'default'
 }

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

@@ -35,13 +35,9 @@
     ]]>
     </change-notes>
 
-    <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/build_number_ranges.html for description -->
-    <idea-version since-build="191.0" until-build="192.0" />
+    <idea-version since-build="193.0" until-build="194.0" />
 
-    <!-- please see http://confluence.jetbrains.com/display/IDEADEV/Plugin+Compatibility+with+IntelliJ+Platform+Products
-         on how to target different products -->
-
-    <!--<depends>com.intellij.modules.lang</depends>-->
+    <depends>com.intellij.modules.java</depends>
     <depends>gherkin</depends>
     <depends>org.intellij.scala</depends>
 

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

@@ -1,35 +1,34 @@
 package com.github.danielwegener.intellij.cucumber.scala
 
-import java.util.{ Collections, Collection => JavaCollection, Set => JavaSet }
+import java.util.{Collection => JavaCollection}
 
 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.module.{Module, ModuleUtilCore}
 import com.intellij.openapi.project.Project
-import com.intellij.psi._
 import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.{JavaPsiFacade, PsiElement, PsiFile}
 import org.jetbrains.annotations.NotNull
-import org.jetbrains.plugins.cucumber.{ BDDFrameworkType, StepDefinitionCreator }
 import org.jetbrains.plugins.cucumber.psi.GherkinFile
-import org.jetbrains.plugins.cucumber.steps.{ AbstractCucumberExtension, AbstractStepDefinition }
+import org.jetbrains.plugins.cucumber.steps.{AbstractCucumberExtension, AbstractStepDefinition}
+import org.jetbrains.plugins.cucumber.{BDDFrameworkType, StepDefinitionCreator}
 import org.jetbrains.plugins.scala.ScalaFileType
 import org.jetbrains.plugins.scala.lang.psi
 import org.jetbrains.plugins.scala.lang.psi.api.ScalaFile
 import org.jetbrains.plugins.scala.lang.psi.api.expr.ScMethodCall
-import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef.{ ScTrait, ScTypeDefinition, ScClass }
+import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef.{ScClass, ScTrait, ScTypeDefinition}
+import org.jetbrains.plugins.scala.lang.psi.stubs.util.ScalaInheritors
 
 import scala.annotation.tailrec
 import scala.collection.JavaConverters
 import scala.util.Try
 
 object CucumberScalaExtension {
-  val LOG = Logger.getInstance(classOf[CucumberScalaExtension])
+  val LOG: Logger = Logger.getInstance(classOf[CucumberScalaExtension])
 }
 
 class CucumberScalaExtension extends AbstractCucumberExtension {
 
-  import com.github.danielwegener.intellij.cucumber.scala.CucumberScalaExtension._
-
   val CUCUMBER_RUNTIME_SCALA_STEP_DEF_TRAIT = "cucumber.api.scala.ScalaDsl"
 
   override def isStepLikeFile(@NotNull child: PsiElement, @NotNull parent: PsiElement): Boolean = {
@@ -50,20 +49,14 @@ class CucumberScalaExtension extends AbstractCucumberExtension {
   @NotNull
   override def getStepDefinitionCreator: StepDefinitionCreator = throw new UnsupportedOperationException("You cannot automatically create Steps yet.")
 
-  @NotNull override def getGlues(@NotNull file: GherkinFile, jGluesFromOtherFiles: JavaSet[String]): JavaCollection[String] = {
-    // never called? wtf
-    LOG.debug("GET GLUES CALLED")
-    Collections.emptyList()
-  }
-
   override def loadStepsFor(featureFile: PsiFile, module: Module): java.util.List[AbstractStepDefinition] = {
 
     val dependenciesScope: GlobalSearchScope = module.getModuleWithDependenciesAndLibrariesScope(true)
     val project: Project = featureFile.getProject
 
     val stepDefs = for {
       cucumberDslClass <- JavaPsiFacade.getInstance(project).findClasses(CUCUMBER_RUNTIME_SCALA_STEP_DEF_TRAIT, dependenciesScope)
-      scalaDslInheritingClass <- psi.stubs.util.ScalaStubsUtil.getClassInheritors(cucumberDslClass, dependenciesScope).collect { case sc: ScClass => sc; case sct: ScTrait => sct }
+      scalaDslInheritingClass <- psi.stubs.util.ScalaInheritors.withStableScalaInheritors(cucumberDslClass).collect { case sc: ScClass => sc; case sct: ScTrait => sct }
       glueCodeClass <- classAndItsInheritors(scalaDslInheritingClass, dependenciesScope)
       scConstructorBody <- glueCodeClass.extendsBlock.templateBody.toSeq
       outerMethodCall <- scConstructorBody.getChildren.collect { case mc: ScMethodCall => mc }
@@ -80,14 +73,15 @@ class CucumberScalaExtension extends AbstractCucumberExtension {
       queue match {
         case Nil => akku
         case a =>
-          val newChildren = psi.stubs.util.ScalaStubsUtil.getClassInheritors(a.head, scope)
+          val newChildren = ScalaInheritors.findInheritorObjects(a.head)
             .collect { case sc: ScClass => sc; case sct: ScTrait => sct }
-            .filterNot(akku.contains)
+            .filterNot(akku.contains _)
           rec(a.tail ::: newChildren.toList, akku + a.head)
 
       }
 
     }
+
     rec(List(parentOfHierarchy), Set.empty)
   }
 
@@ -100,7 +94,7 @@ class CucumberScalaExtension extends AbstractCucumberExtension {
       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.ScalaStubsUtil.getClassInheritors(cucumberDslClass, searchScope)
+      scalaDslInheritingClass@(some: ScClass) <- psi.stubs.util.ScalaInheritors.withStableScalaInheritors(cucumberDslClass)
       glueCodeClass <- classAndItsInheritors(scalaDslInheritingClass, searchScope)
       containingFile <- Try(glueCodeClass.getContainingFile).toOption
     } yield containingFile

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

@@ -10,7 +10,7 @@ import com.intellij.openapi.diagnostic.Logger
 import java.util.Collections
 
 object ScalaStepDefinition {
-  val LOG = Logger.getInstance(classOf[ScalaStepDefinition])
+  val LOG: Logger = Logger.getInstance(classOf[ScalaStepDefinition])
 }
 
 class ScalaStepDefinition(scMethod: ScMethodCall) extends AbstractStepDefinition(scMethod) {

example/build.gradle

@@ -7,7 +7,6 @@ description "Example project Cucumber for Scala"
 
 dependencies {
     implementation libs.scala
-
+    testCompile libs.cucumberScala
     testCompile libs.jUnit
-    testCompile libs.cucumber
 }