Implement scenario scoped glue code for classes

Author: gaeljw

scala/sources/src/main/scala/io/cucumber/scala/AbstractGlueDefinition.scala

@@ -1,15 +1,32 @@
 package io.cucumber.scala
 
-import io.cucumber.core.backend.Located
+import java.lang.reflect.InvocationTargetException
 
-abstract class AbstractGlueDefinition(location: StackTraceElement) extends Located {
+import io.cucumber.core.backend.{CucumberInvocationTargetException, Located}
 
-  def getLocation(): String = {
+import scala.util.{Failure, Try}
+
+trait AbstractGlueDefinition extends Located {
+
+  val location: StackTraceElement
+
+  override def getLocation(): String = {
     location.toString
   }
 
-  def isDefinedAt(stackTraceElement: StackTraceElement): Boolean = {
+  override def isDefinedAt(stackTraceElement: StackTraceElement): Boolean = {
     location.getFileName != null && location.getFileName == stackTraceElement.getFileName
   }
 
+  /**
+   * Executes the block of code and handle failures in the way asked by Cucumber specification: that is throwing a CucumberInvocationTargetException.
+   */
+  protected def executeAsCucumber(block: => Unit): Unit = {
+    Try(block)
+      .recoverWith {
+        case ex => Failure(new CucumberInvocationTargetException(this, new InvocationTargetException(ex)))
+      }
+      .get
+  }
+
 }

scala/sources/src/main/scala/io/cucumber/scala/GlueAdaptor.scala

@@ -4,12 +4,18 @@ import io.cucumber.core.backend.Glue
 
 class GlueAdaptor(glue: Glue) {
 
-  def addDefinition(registry: ScalaDslRegistry): Unit = {
-    registry.stepDefinitions.foreach(glue.addStepDefinition)
-    registry.beforeHooks.foreach(glue.addBeforeHook)
-    registry.afterHooks.foreach(glue.addAfterHook)
-    registry.afterStepHooks.foreach(glue.addAfterStepHook)
-    registry.beforeStepHooks.foreach(glue.addBeforeStepHook)
+  /**
+   * Load the step definitions and hooks from a ScalaDsl instance into the glue.
+   *
+   * @param registry       ScalaDsl instance registry
+   * @param scenarioScoped true for class instances, false for object singletons
+   */
+  def loadRegistry(registry: ScalaDslRegistry, scenarioScoped: Boolean): Unit = {
+    registry.stepDefinitions.map(ScalaStepDefinition(_, scenarioScoped)).foreach(glue.addStepDefinition)
+    registry.beforeHooks.map(ScalaHookDefinition(_, scenarioScoped)).foreach(glue.addBeforeHook)
+    registry.afterHooks.map(ScalaHookDefinition(_, scenarioScoped)).foreach(glue.addAfterHook)
+    registry.afterStepHooks.map(ScalaHookDefinition(_, scenarioScoped)).foreach(glue.addAfterStepHook)
+    registry.beforeStepHooks.map(ScalaHookDefinition(_, scenarioScoped)).foreach(glue.addBeforeStepHook)
   }
 
 }

scala/sources/src/main/scala/io/cucumber/scala/ScalaBackend.scala

@@ -11,53 +11,58 @@ import io.cucumber.core.resource.{ClasspathScanner, ClasspathSupport}
 import scala.collection.JavaConverters._
 import scala.util.Try
 
-class ScalaBackend(classLoaderProvider: Supplier[ClassLoader]) extends Backend {
+class ScalaBackend(lookup: Lookup, container: Container, classLoaderProvider: Supplier[ClassLoader]) extends Backend {
 
   private val classFinder = new ClasspathScanner(classLoaderProvider)
 
-  private[scala] var scalaGlueInstances: Seq[ScalaDsl] = Nil
+  private var glueAdaptor: GlueAdaptor = _
+  private[scala] var scalaGlueClasses: Seq[Class[_ <: ScalaDsl]] = Nil
 
   override def disposeWorld(): Unit = {
-    scalaGlueInstances = Nil
+    // Nothing to do
   }
 
   override def getSnippet(): Snippet = {
     new ScalaSnippet()
   }
 
   override def buildWorld(): Unit = {
-    // Nothing to do
+    // Instantiate all the glue classes and load the glue code from them
+    scalaGlueClasses.foreach { glueClass =>
+      val glueInstance = lookup.getInstance(glueClass)
+      glueAdaptor.loadRegistry(glueInstance.registry, scenarioScoped = true)
+    }
   }
 
   override def loadGlue(glue: Glue, gluePaths: JList[URI]): Unit = {
 
+    glueAdaptor = new GlueAdaptor(glue)
+
     val dslClasses = gluePaths.asScala
       .filter(gluePath => ClasspathSupport.CLASSPATH_SCHEME.equals(gluePath.getScheme))
       .map(ClasspathSupport.packageName)
       .flatMap(basePackageName => classFinder.scanForSubClassesInPackage(basePackageName, classOf[ScalaDsl]).asScala)
       .filter(glueClass => !glueClass.isInterface)
-      .filter(glueClass => glueClass.getConstructors.length > 0)
 
     val (clsClasses, objClasses) = dslClasses.partition(isRegularClass)
 
+    // Retrieve Scala objects (singletons)
     val objInstances = objClasses.map { cls =>
       val instField = cls.getDeclaredField("MODULE$")
       instField.setAccessible(true)
       instField.get(null).asInstanceOf[ScalaDsl]
     }
-    val clsInstances = clsClasses.map {
-      _.newInstance()
-    }
-
-    // FIXME we should not create instances above but fill the container like Cucumber Java does
-    // https://github.com/cucumber/cucumber-jvm-scala/issues/1
-    //clsClasses.foreach(container.addClass(_))
-    scalaGlueInstances = objInstances.toSeq ++ clsInstances
 
-    val glueAdaptor = new GlueAdaptor(glue)
+    // Regular Scala classes are added to the container, they will be instantiated by the container depending on its logic
+    // Object are not because by definition they are singletons
+    clsClasses.foreach { glueClass =>
+      container.addClass(glueClass)
+      scalaGlueClasses = scalaGlueClasses :+ glueClass
+    }
 
-    scalaGlueInstances.foreach { glueInstance =>
-      glueAdaptor.addDefinition(glueInstance.registry)
+    // For object, we add the definitions here, once for all
+    objInstances.foreach { glueInstance =>
+      glueAdaptor.loadRegistry(glueInstance.registry, scenarioScoped = false)
     }
 
     ()

scala/sources/src/main/scala/io/cucumber/scala/ScalaBackendProviderService.scala

@@ -7,7 +7,7 @@ import io.cucumber.core.backend.{Backend, BackendProviderService, Container, Loo
 class ScalaBackendProviderService extends BackendProviderService {
 
   override def create(lookup: Lookup, container: Container, classLoaderSupplier: Supplier[ClassLoader]): Backend = {
-    new ScalaBackend(classLoaderSupplier)
+    new ScalaBackend(lookup, container, classLoaderSupplier)
   }
 
 }