Added scalafmt to core

10 files changed, 111 insertions, 115 deletions

diff --git a/.scalafmt b/.scalafmt
index de01a04..4a04fdf 100644
--- a/.scalafmt
+++ b/.scalafmt
@@ -2,10 +2,21 @@
 # refer to https://olafurpg.github.io/scalafmt/#Configuration for properties
 
 --style defaultWithAlign # For pretty alignment.
---maxColumn 100          # For my wide 30" display.
+--maxColumn 120          # For my wide 30" display.
+
+--reformatDocstrings true
+--scalaDocs
 
 --continuationIndentCallSite 4
 --continuationIndentDefnSite 4
 
-#--alignTokens
-#--assumeStandardLibraryStripMargin
\ No newline at end of file
+--rewriteTokens ⇒;=>,←;<-
+--danglingParentheses false
+--spaceAfterTripleEquals true
+--alignByArrowEnumeratorGenerator true
+--binPackParentConstructors true
+--allowNewlineBeforeColonInMassiveReturnTypes true
+--spacesInImportCurlyBraces true
+
+# --alignByOpenParenCallSite <value>
+# --alignByOpenParenDefnSite <value>
diff --git a/src/main/scala/com/drivergrp/core/app.scala b/src/main/scala/com/drivergrp/core/app.scala
index 5006761..488fdd3 100644
--- a/src/main/scala/com/drivergrp/core/app.scala
+++ b/src/main/scala/com/drivergrp/core/app.scala
@@ -6,11 +6,11 @@ import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
 import akka.http.scaladsl.model.StatusCodes
 import akka.http.scaladsl.server.Directives._
 import akka.http.scaladsl.server.RouteResult._
-import akka.http.scaladsl.server.{Route, RouteConcatenation}
+import akka.http.scaladsl.server.{ Route, RouteConcatenation }
 import akka.stream.ActorMaterializer
-import com.drivergrp.core.logging.{Logger, TypesafeScalaLogger}
+import com.drivergrp.core.logging.{ Logger, TypesafeScalaLogger }
 import com.drivergrp.core.rest.Swagger
-import com.drivergrp.core.time.provider.{SystemTimeProvider, TimeProvider}
+import com.drivergrp.core.time.provider.{ SystemTimeProvider, TimeProvider }
 import com.typesafe.config.Config
 import org.slf4j.LoggerFactory
 import spray.json.DefaultJsonProtocol
@@ -18,36 +18,36 @@ import spray.json.DefaultJsonProtocol
 import scala.concurrent.Await
 import scala.concurrent.duration._
 
-
 object app {
 
-  class DriverApp(version: String, buildNumber: Int,
+  class DriverApp(version: String,
+                  buildNumber: Int,
                   modules: Seq[Module],
                   time: TimeProvider = new SystemTimeProvider(),
                   log: Logger = new TypesafeScalaLogger(
-                    com.typesafe.scalalogging.Logger(LoggerFactory.getLogger(classOf[DriverApp]))),
+                      com.typesafe.scalalogging.Logger(LoggerFactory.getLogger(classOf[DriverApp]))),
                   config: Config = com.drivergrp.core.config.loadDefaultConfig,
-                  interface: String = "localhost", port: Int = 8080) {
+                  interface: String = "localhost",
+                  port: Int = 8080) {
 
-    implicit private lazy val actorSystem = ActorSystem("spray-routing", config)
+    implicit private lazy val actorSystem      = ActorSystem("spray-routing", config)
     implicit private lazy val executionContext = actorSystem.dispatcher
-    implicit private lazy val materializer = ActorMaterializer()(actorSystem)
-    private lazy val http = Http()(actorSystem)
-
+    implicit private lazy val materializer     = ActorMaterializer()(actorSystem)
+    private lazy val http                      = Http()(actorSystem)
 
     def run() = {
       activateServices(modules)
       scheduleServicesDeactivation(modules)
       bindHttp(modules)
-      Console.print(s"${this.getClass.getName} App is started")
+      Console.print(s"${ this.getClass.getName } App is started")
     }
 
     def stop() = {
       http.shutdownAllConnectionPools().onComplete { _ =>
-        val _ = actorSystem.terminate()
-        val terminated = Await.result(actorSystem.whenTerminated, 30.seconds)
-        val addressTerminated = if(terminated.addressTerminated) "is" else "is not"
-        Console.print(s"${this.getClass.getName} App $addressTerminated stopped ")
+        val _                 = actorSystem.terminate()
+        val terminated        = Await.result(actorSystem.whenTerminated, 30.seconds)
+        val addressTerminated = if (terminated.addressTerminated) "is" else "is not"
+        Console.print(s"${ this.getClass.getName } App $addressTerminated stopped ")
       }
     }
 
@@ -55,22 +55,24 @@ object app {
       import SprayJsonSupport._
       import DefaultJsonProtocol._
 
-      val serviceTypes = modules.flatMap(_.routeTypes)
+      val serviceTypes   = modules.flatMap(_.routeTypes)
       val swaggerService = new Swagger(actorSystem, serviceTypes, config)
-      val swaggerRoutes = swaggerService.routes ~ swaggerService.swaggerUI
+      val swaggerRoutes  = swaggerService.routes ~ swaggerService.swaggerUI
 
       val versionRoute = path("version") {
-        complete(Map(
-          "version" -> version,
-          "buildNumber" -> buildNumber.toString,
-          "serverTime" -> time.currentTime().millis.toString
-        ))
+        complete(
+            Map(
+                "version"     -> version,
+                "buildNumber" -> buildNumber.toString,
+                "serverTime"  -> time.currentTime().millis.toString
+            ))
       }
 
       val _ = http.bindAndHandle(
-        route2HandlerFlow(logRequestResult("log")(
-          modules.map(_.route).foldLeft(versionRoute ~ swaggerRoutes)(_ ~ _))),
-        interface, port)(materializer)
+          route2HandlerFlow(
+              logRequestResult("log")(modules.map(_.route).foldLeft(versionRoute ~ swaggerRoutes)(_ ~ _))),
+          interface,
+          port)(materializer)
     }
 
     /**
@@ -78,12 +80,12 @@ object app {
       */
     protected def activateServices(services: Seq[Module]) = {
       services.foreach { service =>
-        Console.print(s"Service ${service.name} starts ...")
+        Console.print(s"Service ${ service.name } starts ...")
         try {
           service.activate()
         } catch {
           case t: Throwable =>
-            log.fatal(s"Service ${service.name} failed to activate", t)
+            log.fatal(s"Service ${ service.name } failed to activate", t)
             Console.print(" Failed! (check log)")
         }
         Console.println(" Done")
@@ -97,12 +99,12 @@ object app {
       Runtime.getRuntime.addShutdownHook(new Thread() {
         override def run(): Unit = {
           services.foreach { service =>
-            Console.print(s"Service ${service.name} shutting down ...")
+            Console.print(s"Service ${ service.name } shutting down ...")
             try {
               service.deactivate()
             } catch {
               case t: Throwable =>
-                log.fatal(s"Service ${service.name} failed to deactivate", t)
+                log.fatal(s"Service ${ service.name } failed to deactivate", t)
                 Console.print(" Failed! (check log)")
             }
             Console.println(" Done")
@@ -112,7 +114,6 @@ object app {
     }
   }
 
-
   import scala.reflect.runtime.universe._
 
   trait Module {
@@ -120,14 +121,14 @@ object app {
     def route: Route
     def routeTypes: Seq[Type]
 
-    def activate(): Unit = {}
+    def activate(): Unit   = {}
     def deactivate(): Unit = {}
   }
 
   class EmptyModule extends Module {
     val name = "Nothing"
     def route: Route = complete(StatusCodes.OK)
-    def routeTypes = Seq.empty[Type]
+    def routeTypes   = Seq.empty[Type]
   }
 
   class SimpleModule(val name: String, val route: Route, routeType: Type) extends Module {
@@ -142,13 +143,12 @@ object app {
     *             generalize the name from the composed modules' names
     * @param modules modules to compose into a single one
     */
-  class CompositeModule(val name: String, modules: Seq[Module])
-    extends Module with RouteConcatenation {
+  class CompositeModule(val name: String, modules: Seq[Module]) extends Module with RouteConcatenation {
 
     def route: Route = modules.map(_.route).reduce(_ ~ _)
-    def routeTypes = modules.flatMap(_.routeTypes)
+    def routeTypes   = modules.flatMap(_.routeTypes)
 
-    override def activate() = modules.foreach(_.activate())
+    override def activate()   = modules.foreach(_.activate())
     override def deactivate() = modules.reverse.foreach(_.deactivate())
   }
 }
diff --git a/src/main/scala/com/drivergrp/core/config.scala b/src/main/scala/com/drivergrp/core/config.scala
index ac4c609..29cd9ed 100644
--- a/src/main/scala/com/drivergrp/core/config.scala
+++ b/src/main/scala/com/drivergrp/core/config.scala
@@ -3,18 +3,16 @@ package com.drivergrp.core
 import java.io.File
 import com.typesafe.config.{Config, ConfigFactory}
 
-
 object config {
 
   def loadDefaultConfig: Config = {
-    val configDefaults =
-      ConfigFactory.load(this.getClass.getClassLoader, "application.conf")
+    val configDefaults = ConfigFactory.load(this.getClass.getClassLoader, "application.conf")
 
     scala.sys.props.get("application.config") match {
 
       case Some(filename) =>
         val configFile = new File(filename)
-        if(configFile.exists()) {
+        if (configFile.exists()) {
           ConfigFactory.parseFile(configFile).withFallback(configDefaults)
         } else {
           throw new IllegalStateException(s"No config found at $filename")
diff --git a/src/main/scala/com/drivergrp/core/core.scala b/src/main/scala/com/drivergrp/core/core.scala
index bd6b698..c1e3d7b 100644
--- a/src/main/scala/com/drivergrp/core/core.scala
+++ b/src/main/scala/com/drivergrp/core/core.scala
@@ -2,7 +2,6 @@ package com.drivergrp
 
 import scalaz.Equal
 
-
 package object core {
   import scala.language.reflectiveCalls
 
@@ -19,7 +18,6 @@ package object core {
     }
   }
 
-
   private[core] trait Tagged[+V, +Tag]
   type @@[+V, +Tag] = V with Tagged[V, Tag]
 
diff --git a/src/main/scala/com/drivergrp/core/database.scala b/src/main/scala/com/drivergrp/core/database.scala
index b23c953..beabbff 100644
--- a/src/main/scala/com/drivergrp/core/database.scala
+++ b/src/main/scala/com/drivergrp/core/database.scala
@@ -4,7 +4,6 @@ import scala.concurrent.Future
 import slick.backend.DatabaseConfig
 import slick.driver.JdbcProfile
 
-
 object database {
 
   trait Database {
@@ -18,26 +17,24 @@ object database {
       val dbConfig: DatabaseConfig[JdbcProfile] = DatabaseConfig.forConfig(databaseName)
 
       new Database {
-        val profile: JdbcProfile = dbConfig.driver
+        val profile: JdbcProfile                   = dbConfig.driver
         val database: JdbcProfile#Backend#Database = dbConfig.db
       }
     }
   }
 
-
   trait IdColumnTypes {
     val database: Database
 
     import database.profile.api._
 
     implicit def idColumnType[T] =
-      MappedColumnType.base[Id[T], Long]({ id => id: Long }, { id => Id[T](id) })
+      MappedColumnType.base[Id[T], Long](id => id: Long, Id[T](_))
 
     implicit def nameColumnType[T] =
-      MappedColumnType.base[Name[T], String]({ name => name: String }, { name => Name[T](name) })
+      MappedColumnType.base[Name[T], String](name => name: String, Name[T](_))
   }
 
-
   trait DatabaseObject extends IdColumnTypes {
 
     def createTables(): Future[Unit]
@@ -46,6 +43,6 @@ object database {
 
   abstract class DatabaseObjectAdapter extends DatabaseObject {
     def createTables(): Future[Unit] = Future.successful(())
-    def disconnect(): Unit = {}
+    def disconnect(): Unit           = {}
   }
 }
diff --git a/src/main/scala/com/drivergrp/core/generators.scala b/src/main/scala/com/drivergrp/core/generators.scala
index 7f51078..6055cd0 100644
--- a/src/main/scala/com/drivergrp/core/generators.scala
+++ b/src/main/scala/com/drivergrp/core/generators.scala
@@ -6,7 +6,6 @@ import com.drivergrp.core.time.{Time, TimeRange}
 import scala.reflect.ClassTag
 import scala.util.Random
 
-
 object generators {
 
   private val random = new Random
@@ -14,14 +13,13 @@ object generators {
 
   private val DefaultMaxLength = 100
 
-
   def nextId[T](): Id[T] = Id[T](nextLong())
 
   def nextName[T](maxLength: Int = DefaultMaxLength): Name[T] = Name[T](nextString(maxLength))
 
   def nextString(maxLength: Int = DefaultMaxLength) = random.nextString(maxLength)
 
-  def nextOption[T](value: => T): Option[T] = if(nextBoolean) Option(value) else None
+  def nextOption[T](value: => T): Option[T] = if (nextBoolean) Option(value) else None
 
   def nextPair[L, R](left: => L, right: => R): (L, R) = (left, right)
 
@@ -36,7 +34,8 @@ object generators {
 
   def oneOf[T](items: Seq[T]): T = items(nextInt(items.size))
 
-  def arrayOf[T : ClassTag](generator: => T, maxLength: Int = DefaultMaxLength): Array[T] = Array.fill(maxLength)(generator)
+  def arrayOf[T: ClassTag](generator: => T, maxLength: Int = DefaultMaxLength): Array[T] =
+    Array.fill(maxLength)(generator)
 
   def seqOf[T](generator: => T, maxLength: Int = DefaultMaxLength): Seq[T] = Seq.fill(maxLength)(generator)
 
@@ -48,4 +47,4 @@ object generators {
 
   def mapOf[K, V](maxLength: Int, keyGenerator: => K, valueGenerator: => V): Map[K, V] =
     seqOf(nextPair(keyGenerator, valueGenerator), maxLength).toMap
-}
\ No newline at end of file
+}
diff --git a/src/main/scala/com/drivergrp/core/logging.scala b/src/main/scala/com/drivergrp/core/logging.scala
index 67a852b..a4557e0 100644
--- a/src/main/scala/com/drivergrp/core/logging.scala
+++ b/src/main/scala/com/drivergrp/core/logging.scala
@@ -2,7 +2,6 @@ package com.drivergrp.core
 
 import org.slf4j.Marker
 
-
 object logging {
 
   trait Logger {
@@ -38,63 +37,63 @@ object logging {
 
   class TypesafeScalaLogger(scalaLogging: com.typesafe.scalalogging.Logger) extends Logger {
 
-    def fatal(message: String): Unit = scalaLogging.error(message)
-    def fatal(message: String, cause: Throwable): Unit = scalaLogging.error(message, cause)
-    def fatal(message: String, args: AnyRef*): Unit = scalaLogging.error(message, args)
-    def fatal(marker: Marker, message: String): Unit = scalaLogging.error(marker, message)
+    def fatal(message: String): Unit                                   = scalaLogging.error(message)
+    def fatal(message: String, cause: Throwable): Unit                 = scalaLogging.error(message, cause)
+    def fatal(message: String, args: AnyRef*): Unit                    = scalaLogging.error(message, args)
+    def fatal(marker: Marker, message: String): Unit                   = scalaLogging.error(marker, message)
     def fatal(marker: Marker, message: String, cause: Throwable): Unit = scalaLogging.error(marker, message, cause)
-    def fatal(marker: Marker, message: String, args: AnyRef*): Unit = scalaLogging.error(marker, message, args)
+    def fatal(marker: Marker, message: String, args: AnyRef*): Unit    = scalaLogging.error(marker, message, args)
 
-    def error(message: String): Unit = scalaLogging.warn(message)
-    def error(message: String, cause: Throwable): Unit = scalaLogging.warn(message, cause)
-    def error(message: String, args: AnyRef*): Unit = scalaLogging.warn(message, args)
-    def error(marker: Marker, message: String): Unit = scalaLogging.warn(marker, message)
+    def error(message: String): Unit                                   = scalaLogging.warn(message)
+    def error(message: String, cause: Throwable): Unit                 = scalaLogging.warn(message, cause)
+    def error(message: String, args: AnyRef*): Unit                    = scalaLogging.warn(message, args)
+    def error(marker: Marker, message: String): Unit                   = scalaLogging.warn(marker, message)
     def error(marker: Marker, message: String, cause: Throwable): Unit = scalaLogging.warn(marker, message, cause)
-    def error(marker: Marker, message: String, args: AnyRef*): Unit = scalaLogging.warn(marker, message, args)
+    def error(marker: Marker, message: String, args: AnyRef*): Unit    = scalaLogging.warn(marker, message, args)
 
-    def audit(message: String): Unit = scalaLogging.info(message)
-    def audit(message: String, cause: Throwable): Unit = scalaLogging.info(message, cause)
-    def audit(message: String, args: AnyRef*): Unit = scalaLogging.info(message, args)
-    def audit(marker: Marker, message: String): Unit = scalaLogging.info(marker, message)
+    def audit(message: String): Unit                                   = scalaLogging.info(message)
+    def audit(message: String, cause: Throwable): Unit                 = scalaLogging.info(message, cause)
+    def audit(message: String, args: AnyRef*): Unit                    = scalaLogging.info(message, args)
+    def audit(marker: Marker, message: String): Unit                   = scalaLogging.info(marker, message)
     def audit(marker: Marker, message: String, cause: Throwable): Unit = scalaLogging.info(marker, message, cause)
-    def audit(marker: Marker, message: String, args: AnyRef*): Unit = scalaLogging.info(marker, message, args)
+    def audit(marker: Marker, message: String, args: AnyRef*): Unit    = scalaLogging.info(marker, message, args)
 
-    def debug(message: String): Unit = scalaLogging.debug(message)
-    def debug(message: String, cause: Throwable): Unit = scalaLogging.debug(message, cause)
-    def debug(message: String, args: AnyRef*): Unit = scalaLogging.debug(message, args)
-    def debug(marker: Marker, message: String): Unit = scalaLogging.debug(marker, message)
+    def debug(message: String): Unit                                   = scalaLogging.debug(message)
+    def debug(message: String, cause: Throwable): Unit                 = scalaLogging.debug(message, cause)
+    def debug(message: String, args: AnyRef*): Unit                    = scalaLogging.debug(message, args)
+    def debug(marker: Marker, message: String): Unit                   = scalaLogging.debug(marker, message)
     def debug(marker: Marker, message: String, cause: Throwable): Unit = scalaLogging.debug(marker, message, cause)
-    def debug(marker: Marker, message: String, args: AnyRef*): Unit = scalaLogging.debug(marker, message, args)
+    def debug(marker: Marker, message: String, args: AnyRef*): Unit    = scalaLogging.debug(marker, message, args)
   }
 
   class NoLogger() extends Logger {
 
-    def fatal(message: String): Unit = {}
-    def fatal(message: String, cause: Throwable): Unit = {}
-    def fatal(message: String, args: AnyRef*): Unit = {}
-    def fatal(marker: Marker, message: String): Unit = {}
+    def fatal(message: String): Unit                                   = {}
+    def fatal(message: String, cause: Throwable): Unit                 = {}
+    def fatal(message: String, args: AnyRef*): Unit                    = {}
+    def fatal(marker: Marker, message: String): Unit                   = {}
     def fatal(marker: Marker, message: String, cause: Throwable): Unit = {}
-    def fatal(marker: Marker, message: String, args: AnyRef*): Unit = {}
+    def fatal(marker: Marker, message: String, args: AnyRef*): Unit    = {}
 
-    def error(message: String): Unit = {}
-    def error(message: String, cause: Throwable): Unit = {}
-    def error(message: String, args: AnyRef*): Unit = {}
-    def error(marker: Marker, message: String): Unit = {}
+    def error(message: String): Unit                                   = {}
+    def error(message: String, cause: Throwable): Unit                 = {}
+    def error(message: String, args: AnyRef*): Unit                    = {}
+    def error(marker: Marker, message: String): Unit                   = {}
     def error(marker: Marker, message: String, cause: Throwable): Unit = {}
-    def error(marker: Marker, message: String, args: AnyRef*): Unit = {}
+    def error(marker: Marker, message: String, args: AnyRef*): Unit    = {}
 
-    def audit(message: String): Unit = {}
-    def audit(message: String, cause: Throwable): Unit = {}
-    def audit(message: String, args: AnyRef*): Unit = {}
-    def audit(marker: Marker, message: String): Unit = {}
+    def audit(message: String): Unit                                   = {}
+    def audit(message: String, cause: Throwable): Unit                 = {}
+    def audit(message: String, args: AnyRef*): Unit                    = {}
+    def audit(marker: Marker, message: String): Unit                   = {}
     def audit(marker: Marker, message: String, cause: Throwable): Unit = {}
-    def audit(marker: Marker, message: String, args: AnyRef*): Unit = {}
+    def audit(marker: Marker, message: String, args: AnyRef*): Unit    = {}
 
-    def debug(message: String): Unit = {}
-    def debug(message: String, cause: Throwable): Unit = {}
-    def debug(message: String, args: AnyRef*): Unit = {}
-    def debug(marker: Marker, message: String): Unit = {}
+    def debug(message: String): Unit                                   = {}
+    def debug(message: String, cause: Throwable): Unit                 = {}
+    def debug(message: String, args: AnyRef*): Unit                    = {}
+    def debug(marker: Marker, message: String): Unit                   = {}
     def debug(marker: Marker, message: String, cause: Throwable): Unit = {}
-    def debug(marker: Marker, message: String, args: AnyRef*): Unit = {}
+    def debug(marker: Marker, message: String, args: AnyRef*): Unit    = {}
   }
 }
diff --git a/src/main/scala/com/drivergrp/core/messages.scala b/src/main/scala/com/drivergrp/core/messages.scala
index 894a6ea..a2d6cbd 100644
--- a/src/main/scala/com/drivergrp/core/messages.scala
+++ b/src/main/scala/com/drivergrp/core/messages.scala
@@ -1,6 +1,5 @@
 package com.drivergrp.core
 
-
 import java.util.Locale
 
 import com.drivergrp.core.logging.Logger
@@ -57,4 +56,4 @@ object messages {
       format(template, params)
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/main/scala/com/drivergrp/core/stats.scala b/src/main/scala/com/drivergrp/core/stats.scala
index 152d4c6..904fcc5 100644
--- a/src/main/scala/com/drivergrp/core/stats.scala
+++ b/src/main/scala/com/drivergrp/core/stats.scala
@@ -5,10 +5,9 @@ import com.drivergrp.core.time.{Time, TimeRange}
 
 object stats {
 
-  type StatsKey = String
+  type StatsKey  = String
   type StatsKeys = Seq[StatsKey]
 
-
   trait Stats {
 
     def recordStats(keys: StatsKeys, interval: TimeRange, value: BigDecimal): Unit
diff --git a/src/main/scala/com/drivergrp/core/time.scala b/src/main/scala/com/drivergrp/core/time.scala
index 074e99d..dfa63c8 100644
--- a/src/main/scala/com/drivergrp/core/time.scala
+++ b/src/main/scala/com/drivergrp/core/time.scala
@@ -5,21 +5,19 @@ import java.util.{Calendar, Date, GregorianCalendar}
 
 import scala.concurrent.duration.Duration
 
-
 object time {
 
   // The most useful time units
-  val Second = 1000L
+  val Second  = 1000L
   val Seconds = Second
-  val Minute = 60 * Seconds
+  val Minute  = 60 * Seconds
   val Minutes = Minute
-  val Hour = 60 * Minutes
-  val Hours = Hour
-  val Day = 24 * Hours
-  val Days = Day
-  val Week = 7 * Days
-  val Weeks = Week
-
+  val Hour    = 60 * Minutes
+  val Hours   = Hour
+  val Day     = 24 * Hours
+  val Days    = Day
+  val Week    = 7 * Days
+  val Weeks   = Week
 
   final case class Time(millis: Long) extends AnyVal {
 
@@ -34,7 +32,6 @@ object time {
 
   implicit def timeOrdering: Ordering[Time] = Ordering.by(_.millis)
 
-
   def startOfMonth(time: Time) = {
     Time(make(new GregorianCalendar()) { cal =>
       cal.setTime(new Date(time.millis))
@@ -48,7 +45,6 @@ object time {
   def textualTime(time: Time): String =
     new SimpleDateFormat("MMM dd, yyyy hh:mm:ss a").format(new Date(time.millis))
 
-
   object provider {
 
     /**