Merge pull request #74 from reactor/Removing_cats_effect

Removing cats-effect which was effectively was only to get ExitCase.

Author: sinwe

build.sbt

@@ -8,7 +8,6 @@ val mockitoInline = "org.mockito" % "mockito-inline" % "3.3.3" % "test"
 val mockitoScala = "org.mockito" %% "mockito-scala" % "1.14.3" % "test"
 val scalaTest = "org.scalatest" %% "scalatest" % "3.1.2" % "test"
 val reactorTest = "io.projectreactor" % "reactor-test" % reactorVersion % "test"
-val catsEffect =  "org.typelevel" %% "cats-effect" % "2.1.3"
 
 //Scala versions for cross compiling
 lazy val scala212 = "2.12.11"
@@ -26,8 +25,7 @@ lazy val root = (project in file("."))
 		libraryDependencies += mockitoScala,
 		libraryDependencies += scalaTest,
 		libraryDependencies += reactorTest,
-		libraryDependencies += mockitoInline,
-		libraryDependencies += catsEffect
+		libraryDependencies += mockitoInline
 	)
 
 // Prevent test being executed in parallel as it may failed for the Scheduler and Virtual Scheduler

src/main/scala/reactor/core/scala/publisher/ExitCondition.scala

@@ -0,0 +1,9 @@
+package reactor.core.scala.publisher
+
+trait ExitCondition
+
+case object Completed extends ExitCondition
+
+case object Cancelled extends ExitCondition
+
+case class Error(ex: Throwable) extends ExitCondition

src/main/scala/reactor/core/scala/publisher/SFluxLike.scala

@@ -3,7 +3,6 @@ package reactor.core.scala.publisher
 import java.util.concurrent.TimeUnit
 import java.util.function.Function
 
-import cats.effect.ExitCase
 import org.reactivestreams.{Publisher, Subscription}
 import reactor.core.publisher.{Flux => JFlux}
 import reactor.core.scheduler.Schedulers
@@ -14,14 +13,14 @@ import scala.util.{Failure, Success, Try}
 
 trait SFluxLike[+T] extends ScalaConverters { self: SFlux[T] =>
 
-  final def bracket[R](use: T => SFlux[R])(release: T => Unit): SFlux[R] = bracketCase(use)((t, _) => release(t))
+  final def using[R](use: T => SFlux[R])(release: T => Unit): SFlux[R] = usingWhen(use)((t, _) => release(t))
 
-  final def bracketCase[R](use: T => SFlux[R])(release: (T, ExitCase[Throwable]) => Unit): SFlux[R] = {
+  final def usingWhen[R](use: T => SFlux[R])(release: (T, ExitCondition) => Unit): SFlux[R] = {
     val f = (t: T) => (Try(use(t)) match {
-      case Success(value) => value.doOnComplete(() => release(t, ExitCase.Completed))
+      case Success(value) => value.doOnComplete(() => release(t, Completed))
       case Failure(exception) => SFlux.error(exception)
-    }).doOnError(ex => release(t, ExitCase.error(ex)))
-      .doOnCancel(() => release(t, ExitCase.canceled))
+    }).doOnError(ex => release(t, Error(ex)))
+      .doOnCancel(() => release(t, Cancelled))
     concatMap(f)
   }
 

src/main/scala/reactor/core/scala/publisher/SMonoLike.scala

@@ -1,7 +1,5 @@
 package reactor.core.scala.publisher
 
-import cats.effect.ExitCase
-import cats.effect.ExitCase.{Canceled, Completed}
 import org.reactivestreams.Publisher
 import reactor.core.publisher.{Mono => JMono}
 
@@ -12,14 +10,14 @@ trait SMonoLike[+T] extends ScalaConverters { self: SMono[T] =>
 
   private[publisher] def coreMono: JMono[_ <: T]
 
-  final def bracket[R](use: T => SMono[R])(release: T => Unit): SMono[R] = bracketCase(use)((t, _) => release(t))
+  final def using[R](use: T => SMono[R])(release: T => Unit): SMono[R] = usingWhen(use)((t, _) => release(t))
 
-  final def bracketCase[R](use: T => SMono[R])(release: (T, ExitCase[Throwable]) => Unit): SMono[R] = {
+  final def usingWhen[R](use: T => SMono[R])(release: (T, ExitCondition) => Unit): SMono[R] = {
     val f: T => SMono[R] = (t: T) => (Try(use(t)) match {
       case Success(value) => value.doOnSuccess(_ => release(t, Completed))
       case Failure(exception) => SMono.error(exception)
-    }).doOnError(ex => release(t, ExitCase.error(ex)))
-        .doOnCancel(() => release(t, Canceled))
+    }).doOnError(ex => release(t, Error(ex)))
+        .doOnCancel(() => release(t, Cancelled))
     flatMap(f)
   }
 

src/test/scala-2.12/reactor/core/scala/publisher/SFlux212Test.scala

@@ -57,7 +57,7 @@ class SFlux212Test extends AnyFreeSpec with Matchers {
           .verifyComplete()
       }
     }
-    "bracketCase" - {
+    "usingWhen" - {
       "should release all resources properly" in {
         import java.io.PrintWriter
         val files = (0 until 5) map(i => {
@@ -68,9 +68,9 @@ class SFlux212Test extends AnyFreeSpec with Matchers {
         })
         files.foreach(f => f.exists() shouldBe true)
         val sf = SFlux.fromIterable(files)
-          .bracketCase(f => {
+          .usingWhen(f => {
             SFlux.just(Source.fromFile(f))
-              .bracket(br => SFlux.fromIterable(br.getLines().toIterable))(_.close())
+              .using(br => SFlux.fromIterable(br.getLines().toIterable))(_.close())
           })((file, _) => file.delete())
         StepVerifier.create(sf)
           .expectNext("0", "1", "2", "3", "4")

src/test/scala-2.13/reactor/core/scala/publisher/SFlux213Test.scala

@@ -65,7 +65,7 @@ class SFlux213Test extends AnyFreeSpec with Matchers {
       }
     }
 
-    ".bracketCase" - {
+    ".usingWhen" - {
       "should release all resources properly" in {
         import java.io.PrintWriter
         val files = (0 until 5) map(i => {
@@ -76,9 +76,9 @@ class SFlux213Test extends AnyFreeSpec with Matchers {
         })
         files.foreach(f => f.exists() shouldBe true)
         val sf = SFlux.fromIterable(files)
-          .bracketCase(f => {
+          .usingWhen(f => {
             SFlux.just(Source.fromFile(f))
-              .bracket(br => SFlux.fromIterable(br.getLines().iterator.to(Iterable)))(_.close())
+              .using(br => SFlux.fromIterable(br.getLines().iterator.to(Iterable)))(_.close())
           })((file, _) => file.delete())
         StepVerifier.create(sf)
           .expectNext("0", "1", "2", "3", "4")

src/test/scala/reactor/core/scala/publisher/SFluxTest.scala

@@ -8,7 +8,6 @@ import java.util.concurrent.Callable
 import java.util.concurrent.atomic.{AtomicBoolean, AtomicInteger, AtomicLong, AtomicReference}
 import java.util.function.Consumer
 
-import cats.effect.ExitCase.Error
 import io.micrometer.core.instrument.Metrics
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry
 import org.mockito.{ArgumentMatchersSugar, IdiomaticMockito}
@@ -524,7 +523,7 @@ class SFluxTest extends AnyFreeSpec with Matchers with TableDrivenPropertyChecks
       }
     }
 
-    ".bracket should always release all resources properly" in {
+    ".using should always release all resources properly" in {
       import java.io.PrintWriter
       val files = (0 until 1) map(i => {
         val path = Files.createTempFile(s"bracketCase-$i", ".tmp")
@@ -534,15 +533,15 @@ class SFluxTest extends AnyFreeSpec with Matchers with TableDrivenPropertyChecks
       })
       files.foreach(f => f.exists() shouldBe true)
       val sf = SFlux.fromIterable(files)
-        .bracket(_ => SFlux.error(new RuntimeException("Always throw exception")))(file => file.delete())
+        .using(_ => SFlux.error(new RuntimeException("Always throw exception")))(file => file.delete())
       StepVerifier.create(sf)
         .expectError(classOf[RuntimeException])
         .verify()
       files.foreach(f => f.exists() shouldBe false)
     }
 
-    ".bracketCase" - {
-      "should handle ExitCase.error" - {
+    ".usingWhen" - {
+      "should handle ExitCondition error" - {
         "when the error happens inside the generated flux" in {
           import java.io.PrintWriter
           val files = (0 until 5) map(i => {
@@ -554,7 +553,7 @@ class SFluxTest extends AnyFreeSpec with Matchers with TableDrivenPropertyChecks
           try {
             files.foreach(f => f.exists() shouldBe true)
             val sf = SFlux.fromIterable(files)
-              .bracketCase(_ => {
+              .usingWhen(_ => {
                 SFlux.error(new RuntimeException("Always throw exception"))
               })((file, exitCase) => {
                 exitCase match {
@@ -582,7 +581,7 @@ class SFluxTest extends AnyFreeSpec with Matchers with TableDrivenPropertyChecks
         try {
           files.foreach(f => f.exists() shouldBe true)
           val sf = SFlux.fromIterable(files)
-            .bracketCase(_ => throw new RuntimeException)((file, exitCase) => {
+            .usingWhen(_ => throw new RuntimeException)((file, exitCase) => {
               exitCase match {
                 case Error(_) => ()
                 case _ => file.delete()

src/test/scala/reactor/core/scala/publisher/SMonoTest.scala

@@ -5,7 +5,6 @@ import java.util.concurrent._
 import java.util.concurrent.atomic.{AtomicBoolean, AtomicInteger, AtomicLong, AtomicReference}
 import java.util.function.Supplier
 
-import cats.effect.ExitCase.Error
 import io.micrometer.core.instrument.Metrics
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry
 import org.mockito.{ArgumentMatchersSugar, IdiomaticMockito}
@@ -426,7 +425,7 @@ class SMonoTest extends AnyFreeSpec with Matchers with TestSupport with Idiomati
 
       file.exists() shouldBe true
       val sMono = SMono.just(file)
-        .bracket(_ => SMono.error(new RuntimeException("Always throw exception")))(file => file.delete())
+        .using(_ => SMono.error(new RuntimeException("Always throw exception")))(file => file.delete())
       StepVerifier.create(sMono)
         .expectError(classOf[RuntimeException])
         .verify()
@@ -442,7 +441,7 @@ class SMonoTest extends AnyFreeSpec with Matchers with TestSupport with Idiomati
 
         file.exists() shouldBe true
         val sMono = SMono.just(file)
-          .bracketCase(f => {
+          .usingWhen(f => {
             val br = Source.fromFile(f)
             val line = br.getLines().mkString
             br.close()
@@ -464,7 +463,7 @@ class SMonoTest extends AnyFreeSpec with Matchers with TestSupport with Idiomati
           try {
             file.exists() shouldBe true
             val sMono = SMono.just(file)
-              .bracketCase(_ => {
+              .usingWhen(_ => {
                 SMono.error(new RuntimeException("Always throw exception"))
               })((file, exitCase) => {
                 exitCase match {
@@ -488,7 +487,7 @@ class SMonoTest extends AnyFreeSpec with Matchers with TestSupport with Idiomati
           try {
             file.exists() shouldBe true
             val sMono = SMono.just(file)
-              .bracketCase(_ => throw new RuntimeException)((file, exitCase) => {
+              .usingWhen(_ => throw new RuntimeException)((file, exitCase) => {
                 exitCase match {
                   case Error(_) => ()
                   case _ => file.delete()