Reformat with scalafmt 3.6.0

Executed command: scalafmt --non-interactive
softwaremill · Oct 18, 2022 · 79fd66e · 79fd66e
1 parent c05b278
commit 79fd66e
Show file tree

Hide file tree

Showing 5 changed files with 194 additions and 236 deletions.
diff --git a/retry/src/main/scala/Defaults.scala b/retry/src/main/scala/Defaults.scala
@@ -1,7 +1,7 @@
 package retry
 
-import scala.concurrent.duration.{ Duration, FiniteDuration }
-import java.util.concurrent.{ ThreadLocalRandom, TimeUnit }
+import scala.concurrent.duration.{Duration, FiniteDuration}
+import java.util.concurrent.{ThreadLocalRandom, TimeUnit}
 
 object Defaults {
   val delay: FiniteDuration = Duration(500, TimeUnit.MILLISECONDS)
@@ -10,4 +10,3 @@ object Defaults {
     Jitter.randomSource(ThreadLocalRandom.current())
   val jitter = Jitter.full()
 }
-
diff --git a/retry/src/main/scala/Jitter.scala b/retry/src/main/scala/Jitter.scala
@@ -6,20 +6,15 @@ import scala.concurrent.duration._
 
 trait Jitter {
 
-  def apply(start: FiniteDuration,
-            last: FiniteDuration,
-            attempt: Int): FiniteDuration =
+  def apply(start: FiniteDuration, last: FiniteDuration, attempt: Int): FiniteDuration =
     next(last, convert(start, last.unit), attempt)
 
-  protected def next(start: FiniteDuration,
-                     last: FiniteDuration,
-                     attempt: Int): FiniteDuration
+  protected def next(start: FiniteDuration, last: FiniteDuration, attempt: Int): FiniteDuration
 
   protected def convert(dur: Duration, unit: TimeUnit): FiniteDuration =
     FiniteDuration(dur.toUnit(unit).toLong, unit)
 
-  protected def capped(input: FiniteDuration, cap: Duration)(
-      op: Long => Long): FiniteDuration = {
+  protected def capped(input: FiniteDuration, cap: Duration)(op: Long => Long): FiniteDuration = {
     if (!cap.isFinite) {
       Duration(op(input.length), input.unit)
     } else {
@@ -36,25 +31,22 @@ trait Jitter {
     else temp.toLong
   }
 
-  protected def cappedPow(start: FiniteDuration,
-                          cap: Duration,
-                          base: Int,
-                          attempt: Int): FiniteDuration =
+  protected def cappedPow(start: FiniteDuration, cap: Duration, base: Int, attempt: Int): FiniteDuration =
     capped(start, cap) { len =>
       pow(len, base, attempt)
     }
 }
 
-/** The algorithms here were inspired by this article:
-  * https://www.awsarchitectureblog.com/2015/03/backoff.html */
+/** The algorithms here were inspired by this article: https://www.awsarchitectureblog.com/2015/03/backoff.html
+  */
 object Jitter {
 
-  /** Given a lower and upper bound (inclusive) generate a random
-    * number within those bounds */
+  /** Given a lower and upper bound (inclusive) generate a random number within those bounds
+    */
   type RandomSource = (Long, Long) => Long
 
-  /** Create a RandomSource from an instance of java.util.Random
-    * Please be mindful of the call-by-name semantics */
+  /** Create a RandomSource from an instance of java.util.Random Please be mindful of the call-by-name semantics
+    */
   def randomSource(random: => Random): RandomSource = { (l, u) =>
     val (_l, _u) = if (l < u) (l, u) else (u, l)
     nextLong(random, (_u - _l) + 1) + _l
@@ -63,22 +55,16 @@ object Jitter {
   /** Simple exponential backoff + cap */
   def none(cap: Duration = Defaults.cap, base: Int = 2): Jitter =
     new Jitter {
-      protected def next(start: FiniteDuration,
-                         last: FiniteDuration,
-                         attempt: Int): FiniteDuration =
+      protected def next(start: FiniteDuration, last: FiniteDuration, attempt: Int): FiniteDuration =
         cappedPow(start, cap, base, attempt)
 
       override def toString = s"retry.Jitter.none($cap, $base)"
     }
 
   /** Normal exponential backoff + cap + random jitter */
-  def full(cap: Duration = Defaults.cap,
-           random: RandomSource = Defaults.random,
-           base: Int = 2): Jitter =
+  def full(cap: Duration = Defaults.cap, random: RandomSource = Defaults.random, base: Int = 2): Jitter =
     new Jitter {
-      protected def next(start: FiniteDuration,
-                         last: FiniteDuration,
-                         attempt: Int): FiniteDuration = {
+      protected def next(start: FiniteDuration, last: FiniteDuration, attempt: Int): FiniteDuration = {
         val temp = cappedPow(start, cap, base, attempt)
         Duration(random(0, temp.length), temp.unit)
       }
@@ -87,13 +73,9 @@ object Jitter {
     }
 
   /** Always keep some of the backoff and jitter by a smaller amount (prevents very short sleeps) */
-  def equal(cap: Duration = Defaults.cap,
-            random: RandomSource = Defaults.random,
-            base: Int = 2): Jitter =
+  def equal(cap: Duration = Defaults.cap, random: RandomSource = Defaults.random, base: Int = 2): Jitter =
     new Jitter {
-      protected def next(start: FiniteDuration,
-                         last: FiniteDuration,
-                         attempt: Int): FiniteDuration = {
+      protected def next(start: FiniteDuration, last: FiniteDuration, attempt: Int): FiniteDuration = {
         val temp = cappedPow(start, cap, base, attempt)
         Duration(temp.length / 2 + random(0, temp.length / 2), temp.unit)
       }
@@ -102,13 +84,9 @@ object Jitter {
     }
 
   /** similar to full, but we also increase the maximum jitter startd on the last random value. */
-  def decorrelated(cap: Duration = Defaults.cap,
-                   random: RandomSource = Defaults.random,
-                   base: Int = 3): Jitter =
+  def decorrelated(cap: Duration = Defaults.cap, random: RandomSource = Defaults.random, base: Int = 3): Jitter =
     new Jitter {
-      protected def next(start: FiniteDuration,
-                         last: FiniteDuration,
-                         attempt: Int): FiniteDuration =
+      protected def next(start: FiniteDuration, last: FiniteDuration, attempt: Int): FiniteDuration =
         capped(start, cap) { len =>
           random(len, last.length * base)
         }