Merge pull request #40 from daddykotex/scala3

Support Scala 3

Author: adamw

build.sbt

@@ -1,6 +1,7 @@
 val scala211 = "2.11.12"
 val scala212 = "2.12.12"
 val scala213 = "2.13.2"
+val scala30 = "3.0.0"
 
 val commonSettings = commonSmlBuildSettings ++ ossPublishSettings
 
@@ -13,14 +14,14 @@ lazy val retry = (projectMatrix in file("retry"))
     name := "retry",
     description := "a library of simple primitives for asynchronously retrying Scala Futures",
     libraryDependencies ++=
-      Seq("org.scalatest" %%% "scalatest" % "3.1.4" % "test",
-        "com.softwaremill.odelay" %%% "odelay-core" % "0.3.2",
-        "org.scala-lang.modules" %%% "scala-collection-compat" % "2.1.6"
+      Seq("org.scalatest" %%% "scalatest" % "3.2.9" % "test",
+        "com.softwaremill.odelay" %%% "odelay-core" % "0.3.3",
+        "org.scala-lang.modules" %%% "scala-collection-compat" % "2.6.0"
       )
   )
   .jvmPlatform(
-    scalaVersions = List(scala211, scala212, scala213)
+    scalaVersions = List(scala211, scala212, scala213, scala30)
   )
   .jsPlatform(
-    scalaVersions = List(scala212, scala213)
+    scalaVersions = List(scala212, scala213, scala30)
   )

project/build.properties

@@ -1 +1 @@
-sbt.version=1.3.12
+sbt.version=1.6.2

project/plugins.sbt

@@ -1,6 +1,6 @@
-addSbtPlugin("com.eed3si9n" % "sbt-projectmatrix" % "0.7.0")
-addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.3.1")
-addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.3.9")
+addSbtPlugin("com.eed3si9n" % "sbt-projectmatrix" % "0.9.0")
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.9.0")
+addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.4.3")
 
 val sbtSoftwaremillVersion = "1.9.15"
 addSbtPlugin("com.softwaremill.sbt-softwaremill" % "sbt-softwaremill-common" % sbtSoftwaremillVersion)

retry/src/main/scala/Policy.scala

@@ -29,11 +29,11 @@ object Directly {
           implicit success: Success[T],
           executor: ExecutionContext): Future[T] = {
         def run(): Future[T] = {
-          retry(promise, run, { _: Future[T] =>
+          retry(promise, run, { (_: Future[T]) =>
             run()
           })
         }
-        run
+        run()
       }
     }
 
@@ -61,7 +61,7 @@ object Pause {
         def run(): Future[T] = {
           val nextRun: () => Future[T] = () =>
             Delay(delay)(run()).future.flatMap(identity)
-          retry(promise, nextRun, { _: Future[T] =>
+          retry(promise, nextRun, { (_: Future[T]) =>
             nextRun()
           })
         }
@@ -131,7 +131,7 @@ object JitterBackoff {
             Delay(delay) {
               run(attempt + 1, jitter(delay, sleep, attempt))
             }.future.flatMap(identity)
-          retry(promise, nextRun, { _: Future[T] =>
+          retry(promise, nextRun, { (_: Future[T]) =>
             nextRun()
           })
         }
@@ -173,7 +173,7 @@ object Backoff {
             Delay(delay) {
               run(Duration(delay.length * base, delay.unit))
             }.future.flatMap(identity)
-          retry(promise, nextRun, { _: Future[T] =>
+          retry(promise, nextRun, { (_: Future[T]) =>
             nextRun()
           })
         }
@@ -246,7 +246,7 @@ trait CountingPolicy extends Policy {
     // consider this successful if our predicate says so _or_
     // we've reached the end out our countdown
     val countedSuccess = success.or(max < 1)
-    retry(promise, () => orElse(max - 1), { f: Future[T] =>
+    retry(promise, () => orElse(max - 1), { (f: Future[T]) =>
       if (max < 1) f else orElse(max - 1)
     })(countedSuccess, executor)
   }

retry/src/test/scala/JitterSpec.scala

@@ -4,17 +4,17 @@ import java.util.Random
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
 
-import org.scalatest.FunSpec
+import org.scalatest.funspec.AnyFunSpec
 import scala.concurrent.duration._
 
-class JitterSpec extends FunSpec {
+class JitterSpec extends AnyFunSpec {
   val rng = new java.util.Random()
   val rand = Jitter.randomSource(rng)
-  val cap = 2000 milliseconds
+  val cap = 2000.millis
 
   def testJitter(jitter: Jitter)(): Unit = {
-    val min = rand(1, 100) milliseconds
-    var sleep = rand(1, 1000) milliseconds
+    val min = rand(1, 100).millis
+    var sleep = rand(1, 1000).millis
 
     for (i <- 0 until 10000) {
       val delay = sleep
@@ -60,25 +60,25 @@ class JitterSpec extends FunSpec {
 
   describe("retry.Jitter.none") {
     it("should perform backoff correctly") {
-      testJitter(Jitter.none(cap))
+      testJitter(Jitter.none(cap))()
     }
   }
 
   describe("retry.Jitter.decorrelated") {
     it("should perform decorrelated jitter correctly") {
-      testJitter(Jitter.decorrelated(cap))
+      testJitter(Jitter.decorrelated(cap))()
     }
   }
 
   describe("retry.Jitter.full") {
     it("should perform full jitter correctly") {
-      testJitter(Jitter.full(cap))
+      testJitter(Jitter.full(cap))()
     }
   }
 
   describe("retry.Jitter.equal") {
     it("should perform equal jitter correctly") {
-      testJitter(Jitter.equal(cap))
+      testJitter(Jitter.equal(cap))()
     }
   }
 

retry/src/test/scala/PolicySpec.scala

@@ -4,7 +4,8 @@ import java.util.Random
 import java.util.concurrent.atomic.{AtomicBoolean, AtomicInteger, AtomicLong}
 
 import odelay.Timer
-import org.scalatest.{AsyncFunSpec, BeforeAndAfterAll}
+import org.scalatest.BeforeAndAfterAll
+import org.scalatest.funspec.AsyncFunSpec
 
 import scala.collection.compat.immutable.LazyList
 import scala.concurrent.Future
@@ -101,7 +102,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
           Future(true)
         }
       val policy = Directly.forever
-      policy(run).map { result =>
+      policy(run()).map { result =>
         assert(result === true)
         assert(retried.get() == 10000)
       }
@@ -135,7 +136,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
           Future(true)
         }
       val policy = Pause.forever(1.millis)
-      policy(run).map { result =>
+      policy(run()).map { result =>
         assert(result === true)
         assert(retried.get() == 1000)
       }
@@ -168,7 +169,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
           Future(true)
         }
       val policy = Backoff.forever(1.millis)
-      policy(run).map { result =>
+      policy(run()).map { result =>
         assert(result === true)
         assert(retried.get() == 5)
       }
@@ -181,15 +182,15 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
 
       it("should retry a future for a specified number of times") {
         implicit val success = Success[Int](_ == 3)
-        implicit val algo = algoCreator(10.millis)
+        implicit val algo: Jitter = algoCreator(10.millis)
         val tries = forwardCountingFutureStream().iterator
         val policy = JitterBackoff(3, 1.milli)
         policy(tries.next).map(result =>
           assert(success.predicate(result) === true))
       }
 
       it("should fail when expected") {
-        implicit val algo = algoCreator(10.millis)
+        implicit val algo: Jitter = algoCreator(10.millis)
         val success = implicitly[Success[Option[Int]]]
         val tries = Future(None: Option[Int])
         val policy = JitterBackoff(3, 1.milli)
@@ -200,7 +201,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
 
       it("should deal with future failures") {
         implicit val success = Success.always
-        implicit val algo = algoCreator(10.millis)
+        implicit val algo: Jitter = algoCreator(10.millis)
         val policy = JitterBackoff(3, 5.millis)
         val counter = new AtomicInteger()
         val future = policy { () =>
@@ -213,7 +214,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
 
       it("should retry futures passed by-name instead of caching results") {
         implicit val success = Success.always
-        implicit val algo = algoCreator(10.millis)
+        implicit val algo: Jitter = algoCreator(10.millis)
         val counter = new AtomicInteger()
         val policy = JitterBackoff(1, 1.milli)
         val future = policy {
@@ -227,7 +228,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
 
       it("should pause with multiplier and jitter between retries") {
         implicit val success = Success[Int](_ == 2)
-        implicit val algo = algoCreator(1000.millis)
+        implicit val algo: Jitter = algoCreator(1000.millis)
         val tries = forwardCountingFutureStream().iterator
         val policy = JitterBackoff(5, 50.millis)
         val marker_base = System.currentTimeMillis
@@ -242,7 +243,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
 
       it("should also work when invoked as forever") {
         implicit val success = Success[Int](_ == 5)
-        implicit val algo = algoCreator(1000.millis)
+        implicit val algo: Jitter = algoCreator(1000.millis)
         val tries = forwardCountingFutureStream().iterator
         val policy = JitterBackoff.forever(50.millis)
         val marker_base = System.currentTimeMillis
@@ -267,7 +268,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
             Future(true)
           }
         val policy = JitterBackoff.forever(1.millis)
-        policy(run).map { result =>
+        policy(run()).map { result =>
           assert(result === true)
           assert(retried.get() == 10)
         }
@@ -325,7 +326,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         // lift an exception into a new policy
         case RetryAfter(duration) => Pause(delay = duration)
       }
-      policy(run).map(result => assert(result === true))
+      policy(run()).map(result => assert(result === true))
     }
 
     it("should repeat on failure until success") {
@@ -344,7 +345,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         // lift an exception into a new policy
         case _: MyException => Directly.forever
       }
-      policy(run).map { result =>
+      policy(run()).map { result =>
         assert(result === true)
         assert(retried.get() == 10000)
       }
@@ -367,7 +368,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         case _: MyException => Pause.forever(1.millis)
 
       }
-      policy(run).map { result =>
+      policy(run()).map { result =>
         assert(result === true)
         assert(retried.get() == 1000)
       }
@@ -389,7 +390,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         // lift an exception into a new policy
         case _: MyException => Backoff.forever(1.millis)
       }
-      policy(run).map { result =>
+      policy(run()).map { result =>
         assert(result === true)
         assert(retried.get() == 5)
       }
@@ -411,7 +412,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         // lift an exception into a new policy
         case _: MyException => JitterBackoff.forever(1.millis)
       }
-      policy(run).map { result =>
+      policy(run()).map { result =>
         assert(result === true)
         assert(retried.get() == 10)
       }

retry/src/test/scala/SuccessSpec.scala

@@ -1,10 +1,10 @@
 package retry
 
-import org.scalatest.FunSpec
+import org.scalatest.funspec.AnyFunSpec
 
 import scala.util.Try
 
-class SuccessSpec extends FunSpec {
+class SuccessSpec extends AnyFunSpec {
   describe("retry.Success.either") {
     val either = implicitly[Success[Either[String, String]]]
     it("should be successful on a Right") {

version.sbt

@@ -1 +1 @@
-version in ThisBuild := "0.3.4-SNAPSHOT"
+ThisBuild / version := "0.3.4-SNAPSHOT"