add scalafmt

Author: Cristian Popovici

.scalafmt.conf

@@ -0,0 +1,89 @@
+version = "2.2.2"
+
+#
+# See http://scalameta.org/scalafmt/#Configuration for details
+#
+project {
+  includeFilters = [
+    ".*.\\.scala$"
+    ".*\\..sbt$"
+  ]
+}
+
+maxColumn = 120
+
+# Vertical alignment, options: none, some, more
+#
+# This awkward, self-contradictory, configuration ensures that only
+# the common sbt tokens get aligned, and not "production" code.
+#
+align = none
+align {
+  openParenCallSite = false
+  openParenDefnSite = false
+  tokens = ["%", ":=", "~=", "<-"]
+}
+
+# If true, the margin character | is aligned with the opening triple quote string literals
+assumeStandardLibraryStripMargin = true
+
+#From scalafmt website:
+#see: http://scalameta.org/scalafmt/#includeCurlyBraceInSelectChains
+includeCurlyBraceInSelectChains = false
+
+continuationIndent {
+  callSite = 2
+  defnSite = 2
+  extendSite = 2
+}
+
+danglingParentheses = false
+
+
+newlines {
+  alwaysBeforeTopLevelStatements = false
+  sometimesBeforeColonInMethodReturnType = true
+  penalizeSingleSelectMultiArgList = false
+  alwaysBeforeElseAfterCurlyIf = false
+  neverInResultType = false
+}
+
+spaces {
+  afterKeywordBeforeParen = true
+}
+
+binPack {
+  parentConstructors = true
+  literalArgumentLists = true
+}
+
+optIn {
+  breaksInsideChains = false
+  breakChainOnFirstMethodDot = true
+  configStyleArguments = true
+}
+
+runner {
+  optimizer {
+    # Set to -1 to disable. Number of characters needed to trigger "config-style" formatting
+    # see: http://scalameta.org/scalafmt/#runner.optimizer.forceConfigStyleOnOffset
+    forceConfigStyleOnOffset = 150
+
+    # minimum number of func arguments before config-style (look at top of file) is enabled
+    forceConfigStyleMinArgCount = 2
+  }
+}
+
+rewrite {
+  rules = [
+    SortImports
+    # if your for has more than one single <- then it gets transformed into a multit-line curly brace one
+    # PreferCurlyFors
+  ]
+}
+
+optIn {
+  blankLineBeforeDocstring = true
+}
+
+lineEndings=preserve

project/build.properties

@@ -1 +1 @@
-sbt.version=0.13.16
+sbt.version=1.2.8

project/plugins.sbt

@@ -1 +1,3 @@
-addSbtPlugin("com.jsuereth" % "sbt-pgp" % "2.0.0")
+addSbtPlugin("com.jsuereth"  % "sbt-pgp"         % "2.0.0")
+addSbtPlugin("org.scalameta" % "sbt-scalafmt"    % "2.2.1")
+

src/main/scala/util/retry/blocking/Retry.scala

@@ -7,72 +7,71 @@ import scala.util.Try
 import scala.util.control.NonFatal
 
 /**
- * The `Retry` type represents a computation that is retrying itself in case of an exception. It uses a `RetryStrategy`
- * as a policy for the retry operation.
- *
- * The result may be successful consisting of the computation result value or a failure that
- * is wrapping the underlying exception. The type is similar to the scala [[scala.util.Try]] type.
- *
- * Example:
- * {{{
- * import scala.concurrent.duration._
- * import util.retry.blocking.{RetryStrategy, Failure, Retry, Success}
- *
- * implicit val retryStrategy =
- *  RetryStrategy.fixedBackOff(retryDuration = 1.seconds, maxAttempts = 2)
- *
- * val r = Retry(1 / 1) match {
- *   case Success(x) => x
- *   case Failure(t) => log("Exception occurred", t)
- * }
- * }}}
- */
+  * The `Retry` type represents a computation that is retrying itself in case of an exception. It uses a `RetryStrategy`
+  * as a policy for the retry operation.
+  *
+  * The result may be successful consisting of the computation result value or a failure that
+  * is wrapping the underlying exception. The type is similar to the scala [[scala.util.Try]] type.
+  *
+  * Example:
+  * {{{
+  * import scala.concurrent.duration._
+  * import util.retry.blocking.{RetryStrategy, Failure, Retry, Success}
+  *
+  * implicit val retryStrategy =
+  *  RetryStrategy.fixedBackOff(retryDuration = 1.seconds, maxAttempts = 2)
+  *
+  * val r = Retry(1 / 1) match {
+  *   case Success(x) => x
+  *   case Failure(t) => log("Exception occurred", t)
+  * }
+  * }}}
+  */
 sealed trait Retry[+T] {
-
   /**
-   * Returns `true` if the `Retry` is a `Failure` otherwise it returns `false`.
-   */
+    * Returns `true` if the `Retry` is a `Failure` otherwise it returns `false`.
+    */
   def flatMap[S](f: T => Retry[S]): Retry[S]
 
   /**
-   * Maps the given function to the value from this `Success` or returns this if this is a `Failure`.
-   */
+    * Maps the given function to the value from this `Success` or returns this if this is a `Failure`.
+    */
   def map[S](f: T => S)(implicit strategy: RetryStrategyProducer): Retry[S]
 
   /**
-   * Returns `true` if the `Retry` is a `Failure` otherwise it returns `false`.
-   */
+    * Returns `true` if the `Retry` is a `Failure` otherwise it returns `false`.
+    */
   def isFailure: Boolean
 
   /**
-   * Returns `true` if the `Retry` is a `Success` otherwise it returns `false` otherwise.
-   */
+    * Returns `true` if the `Retry` is a `Success` otherwise it returns `false` otherwise.
+    */
   def isSuccess: Boolean
 
   /**
-   * Returns the computation value in case of a `Success`.
-   * In case of a `Failure` it throws the underlying exception.
-   */
+    * Returns the computation value in case of a `Success`.
+    * In case of a `Failure` it throws the underlying exception.
+    */
   def get: T
 
   /**
-   * Returns the computation value in case of a `Success`. Otherwise it is returning the provided default.
-   */
+    * Returns the computation value in case of a `Success`. Otherwise it is returning the provided default.
+    */
   def getOrElse[U >: T](default: => U): U = if (isSuccess) get else default
 
   /**
-   * Applies the given function `f` if this is a `Success`, otherwise returns `Unit` if this is a `Failure`.
-   */
+    * Applies the given function `f` if this is a `Success`, otherwise returns `Unit` if this is a `Failure`.
+    */
   def foreach[X](f: T => X)
 
   /**
-   * Applies the given function `f` if this is a `Failure`, otherwise returns this if this is a `Success`.
-   */
+    * Applies the given function `f` if this is a `Failure`, otherwise returns this if this is a `Success`.
+    */
   def recover[X >: T](f: PartialFunction[Throwable, X]): Retry[X]
 
   /**
-   * Transforms the `Retry` value by applying a transformation function to its underlying value
-   */
+    * Transforms the `Retry` value by applying a transformation function to its underlying value
+    */
   def transform[X](f: T => X): X
 }
 
@@ -85,8 +84,7 @@ final case class Success[+T](value: T) extends Retry[T] {
   override def foreach[X](f: T => X): Unit = f(value)
   override def transform[X](f: T => X): X = f(value)
   override def flatMap[S](f: T => Retry[S]): Retry[S] = f(value)
-  override def map[S](f: T => S)(
-    implicit strategy: RetryStrategyProducer): Retry[S] = Retry(f(value))
+  override def map[S](f: T => S)(implicit strategy: RetryStrategyProducer): Retry[S] = Retry(f(value))
 }
 
 final case class Failure[+T](exception: Throwable) extends Retry[T] {
@@ -106,8 +104,7 @@ final case class Failure[+T](exception: Throwable) extends Retry[T] {
   override def foreach[X](f: T => X): Unit = ()
   override def transform[X](f: T => X): X = throw exception
   override def flatMap[S](f: T => Retry[S]): Retry[S] = Failure(exception)
-  override def map[S](f: T => S)(
-    implicit strategy: () => RetryStrategy): Retry[S] = Failure(exception)
+  override def map[S](f: T => S)(implicit strategy: () => RetryStrategy): Retry[S] = Failure(exception)
 }
 
 object Retry {

src/main/scala/util/retry/blocking/RetryStrategy.scala

@@ -9,7 +9,6 @@ import scala.concurrent.blocking
   * Interface defining a retry strategy
   */
 sealed trait RetryStrategy {
-
   /**
     * Returns `true` if the retry should be performed
     */
@@ -45,39 +44,34 @@ class RetryForever(val waitTime: Int) extends RetryStrategy {
 }
 
 class FixedWaitRetryStrategy(val millis: Long, override val maxAttempts: Int)
-    extends MaxNumberOfRetriesStrategy(maxAttempts) with Sleep {
-
+  extends MaxNumberOfRetriesStrategy(maxAttempts) with Sleep {
   override def update(): RetryStrategy = {
     sleep(millis)
     new FixedWaitRetryStrategy(millis, maxAttempts - 1)
   }
 }
 
-class RandomWaitRetryStrategy(val minimumWaitTime: Long,
-                              val maximumWaitTime: Long,
-                              override val maxAttempts: Int)
-    extends MaxNumberOfRetriesStrategy(maxAttempts) with Sleep {
-
+class RandomWaitRetryStrategy(val minimumWaitTime: Long, val maximumWaitTime: Long, override val maxAttempts: Int)
+  extends MaxNumberOfRetriesStrategy(maxAttempts) with Sleep {
   private[this] final val random: Random = new Random()
 
   override def update(): RetryStrategy = {
     val millis: Long =
       math.abs(random.nextLong) % (maximumWaitTime - minimumWaitTime)
     sleep(millis)
     new RandomWaitRetryStrategy(
-        minimumWaitTime,
-        maximumWaitTime,
-        maxAttempts - 1
+      minimumWaitTime,
+      maximumWaitTime,
+      maxAttempts - 1
     )
   }
 }
 
-class FibonacciBackOffStrategy(
-    waitTime: Long, step: Long, override val maxAttempts: Int)
-    extends MaxNumberOfRetriesStrategy(maxAttempts) with Sleep {
+class FibonacciBackOffStrategy(waitTime: Long, step: Long, override val maxAttempts: Int)
+  extends MaxNumberOfRetriesStrategy(maxAttempts) with Sleep {
   def fibonacci(n: Long): Long = {
     n match {
-      case x@(0L | 1L) => x
+      case x @ (0L | 1L) => x
       case _ =>
         var prevPrev: Long = 0L
         var prev: Long = 1L
@@ -111,7 +105,6 @@ sealed trait Sleep {
 }
 
 object RetryStrategy {
-
   type RetryStrategyProducer = () => RetryStrategy
 
   val noRetry: RetryStrategyProducer = () => NoRetry
@@ -125,12 +118,11 @@ object RetryStrategy {
   def fixedBackOff(retryDuration: FiniteDuration, maxAttempts: Int): RetryStrategyProducer =
     () => new FixedWaitRetryStrategy(retryDuration.toMillis, maxAttempts)
 
-  def randomBackOff(minimumWaitDuration: FiniteDuration,
-                    maximumWaitDuration: FiniteDuration,
-                    maxAttempts: Int):RetryStrategyProducer =
-    () => new RandomWaitRetryStrategy(minimumWaitDuration.toMillis,
-                                maximumWaitDuration.toMillis,
-                                maxAttempts)
+  def randomBackOff(
+    minimumWaitDuration: FiniteDuration,
+    maximumWaitDuration: FiniteDuration,
+    maxAttempts: Int): RetryStrategyProducer =
+    () => new RandomWaitRetryStrategy(minimumWaitDuration.toMillis, maximumWaitDuration.toMillis, maxAttempts)
 
   def fibonacciBackOff(initialWaitDuration: FiniteDuration, maxAttempts: Int): RetryStrategyProducer =
     () => new FibonacciBackOffStrategy(initialWaitDuration.toMillis, 1, maxAttempts)