Scalafmtv0.1.2v0.1.1

10 files changed, 128 insertions, 133 deletions

diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala
index 911ecee..5dafc00 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala
@@ -9,7 +9,7 @@ trait DbCommand {
 
 object DbCommand {
   val Empty: DbCommand = new DbCommand {
-    override def runSync(): Unit = {}
+    override def runSync(): Unit                                    = {}
     override def runAsync(transactions: Transactions): Future[Unit] = Future.successful(())
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala
index f12b437..1e2fb74 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala
@@ -8,7 +8,7 @@ trait DbCommandFactory[T] {
 
 object DbCommandFactory {
   def empty[T]: DbCommandFactory[T] = new DbCommandFactory[T] {
-    override def createCommand(orig: T)(implicit ec: ExecutionContext): Future[DbCommand] = Future.successful(DbCommand.Empty)
+    override def createCommand(orig: T)(implicit ec: ExecutionContext): Future[DbCommand] =
+      Future.successful(DbCommand.Empty)
   }
 }
-
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala b/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala
index e13ea39..02ba322 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala
@@ -8,13 +8,12 @@ import io.getquill.dsl.EncodingDsl
 import scala.language.experimental.macros
 import scala.reflect.macros.blackbox
 
-trait EntityExtractorDerivation[Naming <: NamingStrategy] {
-  this: EncodingDsl =>
+trait EntityExtractorDerivation[Naming <: NamingStrategy] { this: EncodingDsl =>
 
-  /**
-    * Simple Quill extractor derivation for [[T]]
-    * Only case classes available. Type parameters is not supported
-    */
+  /*
+    Simple Quill extractor derivation for [[T]]
+    Only case classes available. Type parameters is not supported
+   */
   def entityExtractor[T]: (ResultSet => T) = macro EntityExtractorDerivation.impl[T]
 }
 
@@ -34,16 +33,16 @@ object EntityExtractorDerivation {
         case cons: MethodSymbol if cons.isConstructor =>
           // Create param list for constructor
           val params = cons.paramLists.flatten.map { param =>
-            val t = param.typeSignature
+            val t         = param.typeSignature
             val paramName = param.name.toString
-            val col = q"$namingStrategy.column($paramName)"
+            val col       = q"$namingStrategy.column($paramName)"
             // Resolve implicit decoders (from SqlContext) and apply ResultSet for each
             val d = q"implicitly[${c.prefix}.Decoder[$t]]"
             // Minus 1 cause Quill JDBC decoders make plus one.
             // ¯\_(ツ)_/¯
-            val i = q"row.findColumn($col) - 1"
+            val i           = q"row.findColumn($col) - 1"
             val decoderName = TermName(paramName + "Decoder")
-            val valueName = TermName(paramName + "Value")
+            val valueName   = TermName(paramName + "Value")
             (
               q"val $decoderName = $d",
               q"val $valueName = $decoderName($i, row)",
@@ -59,8 +58,7 @@ object EntityExtractorDerivation {
       }
       resultOpt match {
         case Some(result) => result
-        case None => c.abort(c.enclosingPosition,
-          s"Can not derive extractor for $tpe. Constructor not found.")
+        case None         => c.abort(c.enclosingPosition, s"Can not derive extractor for $tpe. Constructor not found.")
       }
     }
     q"(row: java.sql.ResultSet) => $functionBody"
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala b/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala
index 3b3bbdf..d779e10 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala
@@ -2,8 +2,8 @@ package xyz.driver.pdsuicommon.db
 
 import xyz.driver.pdsuicommon.domain.Id
 
-class EntityNotFoundException private(id: String, tableName: String)
-  extends RuntimeException(s"Entity with id $id is not found in $tableName table") {
+class EntityNotFoundException private (id: String, tableName: String)
+    extends RuntimeException(s"Entity with id $id is not found in $tableName table") {
 
   def this(id: Id[_], tableName: String) = this(id.toString, tableName)
   def this(id: Long, tableName: String) = this(id.toString, tableName)
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala b/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala
index 672a34e..6b7639a 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala
@@ -15,8 +15,7 @@ object MysqlQueryBuilder {
                nullableFields: Set[String],
                links: Set[TableLink],
                runner: Runner[T],
-               countRunner: CountRunner)
-              (implicit ec: ExecutionContext): MysqlQueryBuilder[T] = {
+               countRunner: CountRunner)(implicit ec: ExecutionContext): MysqlQueryBuilder[T] = {
     val parameters = MysqlQueryBuilderParameters(
       tableData = TableData(tableName, lastUpdateFieldName, nullableFields),
       links = links.map(x => x.foreignTableName -> x)(breakOut)
@@ -28,8 +27,7 @@ object MysqlQueryBuilder {
                lastUpdateFieldName: Option[String],
                nullableFields: Set[String],
                links: Set[TableLink],
-               extractor: (ResultSet) => T)
-              (implicit sqlContext: SqlContext): MysqlQueryBuilder[T] = {
+               extractor: (ResultSet) => T)(implicit sqlContext: SqlContext): MysqlQueryBuilder[T] = {
 
     val runner = (parameters: QueryBuilderParameters) => {
       Future {
@@ -43,14 +41,19 @@ object MysqlQueryBuilder {
     val countRunner = (parameters: QueryBuilderParameters) => {
       Future {
         val (sql, binder) = parameters.toSql(countQuery = true, namingStrategy = MysqlEscape)
-        sqlContext.executeQuery[CountResult](sql, binder, { resultSet =>
-          val count = resultSet.getInt(1)
-          val lastUpdate = if (parameters.tableData.lastUpdateFieldName.isDefined) {
-            Option(sqlContext.localDateTimeDecoder.decoder(2, resultSet))
-          } else None
-
-          (count, lastUpdate)
-        }).head
+        sqlContext
+          .executeQuery[CountResult](
+            sql,
+            binder, { resultSet =>
+              val count = resultSet.getInt(1)
+              val lastUpdate = if (parameters.tableData.lastUpdateFieldName.isDefined) {
+                Option(sqlContext.localDateTimeDecoder.decoder(2, resultSet))
+              } else None
+
+              (count, lastUpdate)
+            }
+          )
+          .head
       }(sqlContext.executionContext)
     }
 
@@ -65,11 +68,10 @@ object MysqlQueryBuilder {
   }
 }
 
-class MysqlQueryBuilder[T](parameters: MysqlQueryBuilderParameters)
-                          (implicit runner: QueryBuilder.Runner[T],
-                           countRunner: QueryBuilder.CountRunner,
-                           ec: ExecutionContext)
-  extends QueryBuilder[T, MySQLDialect, MysqlEscape](parameters) {
+class MysqlQueryBuilder[T](parameters: MysqlQueryBuilderParameters)(implicit runner: QueryBuilder.Runner[T],
+                                                                    countRunner: QueryBuilder.CountRunner,
+                                                                    ec: ExecutionContext)
+    extends QueryBuilder[T, MySQLDialect, MysqlEscape](parameters) {
 
   def withFilter(newFilter: SearchFilterExpr): QueryBuilder[T, MySQLDialect, MysqlEscape] = {
     new MysqlQueryBuilder[T](parameters.copy(filter = newFilter))
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala b/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala
index 9b798d8..733d355 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala
@@ -32,9 +32,7 @@ object QueryBuilder {
 
 }
 
-case class TableLink(keyColumnName: String,
-                     foreignTableName: String,
-                     foreignKeyColumnName: String)
+case class TableLink(keyColumnName: String, foreignTableName: String, foreignKeyColumnName: String)
 
 object QueryBuilderParameters {
   val AllFields = Set("*")
@@ -49,7 +47,7 @@ sealed trait QueryBuilderParameters {
   def pagination: Option[Pagination]
 
   def findLink(tableName: String): TableLink = links.get(tableName) match {
-    case None => throw new IllegalArgumentException(s"Cannot find a link for `$tableName`")
+    case None       => throw new IllegalArgumentException(s"Cannot find a link for `$tableName`")
     case Some(link) => link
   }
 
@@ -57,14 +55,12 @@ sealed trait QueryBuilderParameters {
     toSql(countQuery, QueryBuilderParameters.AllFields, namingStrategy)
   }
 
-  def toSql(countQuery: Boolean,
-            fields: Set[String],
-            namingStrategy: NamingStrategy): (String, QueryBuilder.Binder) = {
+  def toSql(countQuery: Boolean, fields: Set[String], namingStrategy: NamingStrategy): (String, QueryBuilder.Binder) = {
     val escapedTableName = namingStrategy.table(tableData.tableName)
     val fieldsSql: String = if (countQuery) {
       "count(*)" + (tableData.lastUpdateFieldName match {
         case Some(lastUpdateField) => s", max($escapedTableName.${namingStrategy.column(lastUpdateField)})"
-        case None => ""
+        case None                  => ""
       })
     } else {
       if (fields == QueryBuilderParameters.AllFields) {
@@ -78,7 +74,7 @@ sealed trait QueryBuilderParameters {
       }
     }
     val (where, bindings) = filterToSql(escapedTableName, filter, namingStrategy)
-    val orderBy = sortingToSql(escapedTableName, sorting, namingStrategy)
+    val orderBy           = sortingToSql(escapedTableName, sorting, namingStrategy)
 
     val limitSql = limitToSql()
 
@@ -92,9 +88,9 @@ sealed trait QueryBuilderParameters {
       import SearchFilterExpr._
       def aux(expr: SearchFilterExpr): Seq[TableLink] = expr match {
         case Atom.TableName(tableName) => List(findLink(tableName))
-        case Intersection(xs) => xs.flatMap(aux)
-        case Union(xs) => xs.flatMap(aux)
-        case _ => Nil
+        case Intersection(xs)          => xs.flatMap(aux)
+        case Union(xs)                 => xs.flatMap(aux)
+        case _                         => Nil
       }
       aux(filter)
     }
@@ -188,33 +184,35 @@ sealed trait QueryBuilderParameters {
         // So, to handle NotEq for nullable fields we need to use more complex SQL expression.
         // http://dev.mysql.com/doc/refman/5.7/en/working-with-null.html
         val escapedColumn = escapeDimension(dimension)
-        val sql = s"($escapedColumn is null or $escapedColumn != ${placeholder(dimension.name)})"
+        val sql           = s"($escapedColumn is null or $escapedColumn != ${placeholder(dimension.name)})"
         (sql, List(value))
 
       case Atom.Binary(dimension, op, value) =>
         val operator = op match {
-          case Eq => "="
+          case Eq    => "="
           case NotEq => "!="
-          case Like => "like"
-          case Gt => ">"
-          case GtEq => ">="
-          case Lt => "<"
-          case LtEq => "<="
+          case Like  => "like"
+          case Gt    => ">"
+          case GtEq  => ">="
+          case Lt    => "<"
+          case LtEq  => "<="
         }
         (s"${escapeDimension(dimension)} $operator ${placeholder(dimension.name)}", List(value))
 
       case Atom.NAry(dimension, op, values) =>
         val sqlOp = op match {
-          case SearchFilterNAryOperation.In => "in"
+          case SearchFilterNAryOperation.In    => "in"
           case SearchFilterNAryOperation.NotIn => "not in"
         }
 
-        val bindings = ListBuffer[AnyRef]()
+        val bindings       = ListBuffer[AnyRef]()
         val sqlPlaceholder = placeholder(dimension.name)
-        val formattedValues = values.map { value =>
-          bindings += value
-          sqlPlaceholder
-        }.mkString(", ")
+        val formattedValues = values
+          .map { value =>
+            bindings += value
+            sqlPlaceholder
+          }
+          .mkString(", ")
         (s"${escapeDimension(dimension)} $sqlOp ($formattedValues)", bindings.toList)
 
       case Intersection(operands) =>
@@ -232,13 +230,11 @@ sealed trait QueryBuilderParameters {
   /**
     * @param escapedMainTableName Should be escaped
     */
-  protected def sortingToSql(escapedMainTableName: String,
-                             sorting: Sorting,
-                             namingStrategy: NamingStrategy): String = {
+  protected def sortingToSql(escapedMainTableName: String, sorting: Sorting, namingStrategy: NamingStrategy): String = {
     sorting match {
       case Dimension(optSortingTableName, field, order) =>
         val sortingTableName = optSortingTableName.map(namingStrategy.table).getOrElse(escapedMainTableName)
-        val fullName = s"$sortingTableName.${namingStrategy.column(field)}"
+        val fullName         = s"$sortingTableName.${namingStrategy.column(field)}"
 
         s"$fullName ${orderToSql(order)}"
 
@@ -248,14 +244,14 @@ sealed trait QueryBuilderParameters {
   }
 
   protected def orderToSql(x: SortingOrder): String = x match {
-    case Ascending => "asc"
+    case Ascending  => "asc"
     case Descending => "desc"
   }
 
-  protected def binder(bindings: List[AnyRef])
-                      (bind: PreparedStatement): PreparedStatement = {
-    bindings.zipWithIndex.foreach { case (binding, index) =>
-      bind.setObject(index + 1, binding)
+  protected def binder(bindings: List[AnyRef])(bind: PreparedStatement): PreparedStatement = {
+    bindings.zipWithIndex.foreach {
+      case (binding, index) =>
+        bind.setObject(index + 1, binding)
     }
 
     bind
@@ -267,7 +263,8 @@ case class PostgresQueryBuilderParameters(tableData: QueryBuilder.TableData,
                                           links: Map[String, TableLink] = Map.empty,
                                           filter: SearchFilterExpr = SearchFilterExpr.Empty,
                                           sorting: Sorting = Sorting.Empty,
-                                          pagination: Option[Pagination] = None) extends QueryBuilderParameters {
+                                          pagination: Option[Pagination] = None)
+    extends QueryBuilderParameters {
 
   def limitToSql(): String = {
     pagination.map { pagination =>
@@ -285,19 +282,23 @@ case class MysqlQueryBuilderParameters(tableData: QueryBuilder.TableData,
                                        links: Map[String, TableLink] = Map.empty,
                                        filter: SearchFilterExpr = SearchFilterExpr.Empty,
                                        sorting: Sorting = Sorting.Empty,
-                                       pagination: Option[Pagination] = None) extends QueryBuilderParameters {
-
-  def limitToSql(): String = pagination.map { pagination =>
-    val startFrom = (pagination.pageNumber - 1) * pagination.pageSize
-    s"limit $startFrom, ${pagination.pageSize}"
-  }.getOrElse("")
+                                       pagination: Option[Pagination] = None)
+    extends QueryBuilderParameters {
+
+  def limitToSql(): String =
+    pagination
+      .map { pagination =>
+        val startFrom = (pagination.pageNumber - 1) * pagination.pageSize
+        s"limit $startFrom, ${pagination.pageSize}"
+      }
+      .getOrElse("")
 
 }
 
-abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameters: QueryBuilderParameters)
-                                                                  (implicit runner: QueryBuilder.Runner[T],
-                                                                   countRunner: QueryBuilder.CountRunner,
-                                                                   ec: ExecutionContext) {
+abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameters: QueryBuilderParameters)(
+        implicit runner: QueryBuilder.Runner[T],
+        countRunner: QueryBuilder.CountRunner,
+        ec: ExecutionContext) {
 
   def run: Future[Seq[T]] = runner(parameters)
 
@@ -307,11 +308,11 @@ abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameter
     * Runs the query and returns total found rows without considering of pagination.
     */
   def runWithCount: Future[(Seq[T], Int, Option[LocalDateTime])] = {
-    val countFuture = runCount
+    val countFuture     = runCount
     val selectAllFuture = run
     for {
       (total, lastUpdate) <- countFuture
-      all <- selectAllFuture
+      all                 <- selectAllFuture
     } yield (all, total, lastUpdate)
   }
 
@@ -323,7 +324,6 @@ abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameter
 
   def resetFilter: QueryBuilder[T, D, N] = withFilter(SearchFilterExpr.Empty)
 
-
   def withSorting(newSorting: Sorting): QueryBuilder[T, D, N]
 
   def withSorting(sorting: Option[Sorting]): QueryBuilder[T, D, N] = {
@@ -332,7 +332,6 @@ abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameter
 
   def resetSorting: QueryBuilder[T, D, N] = withSorting(Sorting.Empty)
 
-
   def withPagination(newPagination: Pagination): QueryBuilder[T, D, N]
 
   def withPagination(pagination: Option[Pagination]): QueryBuilder[T, D, N] = {
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala b/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala
index 60db303..5144163 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala
@@ -49,13 +49,13 @@ object SearchFilterExpr {
     object TableName {
       def unapply(value: Atom): Option[String] = value match {
         case Binary(Dimension(tableNameOpt, _), _, _) => tableNameOpt
-        case NAry(Dimension(tableNameOpt, _), _, _) => tableNameOpt
+        case NAry(Dimension(tableNameOpt, _), _, _)   => tableNameOpt
       }
     }
   }
 
-  case class Intersection private(operands: Seq[SearchFilterExpr])
-    extends SearchFilterExpr with SearchFilterExprSeqOps {
+  case class Intersection private (operands: Seq[SearchFilterExpr])
+      extends SearchFilterExpr with SearchFilterExprSeqOps {
 
     override def replace(f: PartialFunction[SearchFilterExpr, SearchFilterExpr]): SearchFilterExpr = {
       if (f.isDefinedAt(this)) f(this)
@@ -80,8 +80,7 @@ object SearchFilterExpr {
     }
   }
 
-
-  case class Union private(operands: Seq[SearchFilterExpr]) extends SearchFilterExpr with SearchFilterExprSeqOps {
+  case class Union private (operands: Seq[SearchFilterExpr]) extends SearchFilterExpr with SearchFilterExprSeqOps {
 
     override def replace(f: PartialFunction[SearchFilterExpr, SearchFilterExpr]): SearchFilterExpr = {
       if (f.isDefinedAt(this)) f(this)
@@ -123,14 +122,13 @@ object SearchFilterExpr {
 
     /** Create SearchFilterExpr with empty tableName */
     def create(field: String, values: String*): SearchFilterExpr =
-      create(Dimension(None, field), values:_*)
+      create(Dimension(None, field), values: _*)
 
     /** Create SearchFilterExpr with empty tableName */
     def create(field: String, values: Set[String]): SearchFilterExpr =
       create(Dimension(None, field), values)
   }
 
-
   case object AllowAll extends SearchFilterExpr {
     override def find(p: SearchFilterExpr => Boolean): Option[SearchFilterExpr] = {
       if (p(this)) Some(this)
@@ -159,8 +157,7 @@ object SearchFilterExpr {
     expr == Intersection.Empty || expr == Union.Empty
   }
 
-  sealed trait SearchFilterExprSeqOps {
-    this: SearchFilterExpr =>
+  sealed trait SearchFilterExprSeqOps { this: SearchFilterExpr =>
 
     val operands: Seq[SearchFilterExpr]
 
@@ -171,7 +168,7 @@ object SearchFilterExpr {
         // Is's ok to use foldLeft. If there will be performance issues, replace it by recursive loop
         operands.foldLeft(Option.empty[SearchFilterExpr]) {
           case (None, expr) => expr.find(p)
-          case (x, _) => x
+          case (x, _)       => x
         }
       }
     }
@@ -190,13 +187,13 @@ sealed trait SearchFilterBinaryOperation
 
 object SearchFilterBinaryOperation {
 
-  case object Eq extends SearchFilterBinaryOperation
+  case object Eq    extends SearchFilterBinaryOperation
   case object NotEq extends SearchFilterBinaryOperation
-  case object Like extends SearchFilterBinaryOperation
-  case object Gt extends SearchFilterBinaryOperation
-  case object GtEq extends SearchFilterBinaryOperation
-  case object Lt extends SearchFilterBinaryOperation
-  case object LtEq extends SearchFilterBinaryOperation
+  case object Like  extends SearchFilterBinaryOperation
+  case object Gt    extends SearchFilterBinaryOperation
+  case object GtEq  extends SearchFilterBinaryOperation
+  case object Lt    extends SearchFilterBinaryOperation
+  case object LtEq  extends SearchFilterBinaryOperation
 
 }
 
@@ -204,7 +201,7 @@ sealed trait SearchFilterNAryOperation
 
 object SearchFilterNAryOperation {
 
-  case object In extends SearchFilterNAryOperation
+  case object In    extends SearchFilterNAryOperation
   case object NotIn extends SearchFilterNAryOperation
 
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala b/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala
index 4b2427c..b796b83 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala
@@ -7,7 +7,7 @@ import scala.collection.generic.CanBuildFrom
 sealed trait SortingOrder
 object SortingOrder {
 
-  case object Ascending extends SortingOrder
+  case object Ascending  extends SortingOrder
   case object Descending extends SortingOrder
 
 }
@@ -34,25 +34,24 @@ object Sorting {
   def isEmpty(input: Sorting): Boolean = {
     input match {
       case Sequential(Seq()) => true
-      case _ => false
+      case _                 => false
     }
   }
 
   def filter(sorting: Sorting, p: Dimension => Boolean): Seq[Dimension] = sorting match {
     case x: Dimension if p(x) => Seq(x)
-    case x: Dimension => Seq.empty
-    case Sequential(xs) => xs.filter(p)
+    case x: Dimension         => Seq.empty
+    case Sequential(xs)       => xs.filter(p)
   }
 
-  def collect[B, That](sorting: Sorting)
-                      (f: PartialFunction[Dimension, B])
-                      (implicit bf: CanBuildFrom[Seq[Dimension], B, That]): That = sorting match {
+  def collect[B, That](sorting: Sorting)(f: PartialFunction[Dimension, B])(
+          implicit bf: CanBuildFrom[Seq[Dimension], B, That]): That = sorting match {
     case x: Dimension if f.isDefinedAt(x) =>
       val r = bf.apply()
       r += f(x)
       r.result()
 
-    case x: Dimension => bf.apply().result()
+    case x: Dimension   => bf.apply().result()
     case Sequential(xs) => xs.collect(f)
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala b/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala
index 5aa0084..7477e71 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala
@@ -51,8 +51,7 @@ object SqlContext extends PhiLogging {
 }
 
 class SqlContext(dataSource: DataSource with Closeable, settings: Settings)
-  extends MysqlJdbcContext[MysqlEscape](dataSource)
-    with EntityExtractorDerivation[Literal] {
+    extends MysqlJdbcContext[MysqlEscape](dataSource) with EntityExtractorDerivation[Literal] {
 
   private val tpe = Executors.newFixedThreadPool(settings.threadPoolSize)
 
@@ -77,31 +76,31 @@ class SqlContext(dataSource: DataSource with Closeable, settings: Settings)
   implicit override def optionDecoder[T](implicit d: Decoder[T]): Decoder[Option[T]] =
     decoder(
       sqlType = d.sqlType,
-      row => index => {
-        try {
-          val res = d(index - 1, row)
-          if (row.wasNull) {
-            None
+      row =>
+        index => {
+          try {
+            val res = d(index - 1, row)
+            if (row.wasNull) {
+              None
+            } else {
+              Some(res)
+            }
+          } catch {
+            case _: NullPointerException => None
+            case _: IncorrectIdException => None
           }
-          else {
-            Some(res)
-          }
-        } catch {
-          case _: NullPointerException => None
-          case _: IncorrectIdException => None
-        }
       }
     )
 
   implicit def encodeStringId[T] = MappedEncoding[StringId[T], String](_.id)
   implicit def decodeStringId[T] = MappedEncoding[String, StringId[T]] {
     case "" => throw IncorrectIdException("'' is an invalid Id value")
-    case x => StringId(x)
+    case x  => StringId(x)
   }
 
   def decodeOptStringId[T] = MappedEncoding[Option[String], Option[StringId[T]]] {
     case None | Some("") => None
-    case Some(x) => Some(StringId(x))
+    case Some(x)         => Some(StringId(x))
   }
 
   implicit def encodeLongId[T] = MappedEncoding[LongId[T], Long](_.id)
@@ -113,21 +112,22 @@ class SqlContext(dataSource: DataSource with Closeable, settings: Settings)
   // TODO Dirty hack, see REP-475
   def decodeOptLongId[T] = MappedEncoding[Option[Long], Option[LongId[T]]] {
     case None | Some(0) => None
-    case Some(x) => Some(LongId(x))
+    case Some(x)        => Some(LongId(x))
   }
 
   implicit def encodeUuidId[T] = MappedEncoding[UuidId[T], String](_.toString)
   implicit def decodeUuidId[T] = MappedEncoding[String, UuidId[T]] {
     case "" => throw IncorrectIdException("'' is an invalid Id value")
-    case x => UuidId(x)
+    case x  => UuidId(x)
   }
 
   def decodeOptUuidId[T] = MappedEncoding[Option[String], Option[UuidId[T]]] {
     case None | Some("") => None
-    case Some(x) => Some(UuidId(x))
+    case Some(x)         => Some(UuidId(x))
   }
 
-  implicit def encodeTextJson[T: Manifest] = MappedEncoding[TextJson[T], String](x => JsonSerializer.serialize(x.content))
+  implicit def encodeTextJson[T: Manifest] =
+    MappedEncoding[TextJson[T], String](x => JsonSerializer.serialize(x.content))
   implicit def decodeTextJson[T: Manifest] = MappedEncoding[String, TextJson[T]] { x =>
     TextJson(JsonSerializer.deserialize[T](x))
   }
@@ -153,14 +153,14 @@ class SqlContext(dataSource: DataSource with Closeable, settings: Settings)
 
   implicit val encodeFuzzyValue = {
     MappedEncoding[FuzzyValue, String] {
-      case FuzzyValue.No => "No"
-      case FuzzyValue.Yes => "Yes"
+      case FuzzyValue.No    => "No"
+      case FuzzyValue.Yes   => "Yes"
       case FuzzyValue.Maybe => "Maybe"
     }
   }
   implicit val decodeFuzzyValue = MappedEncoding[String, FuzzyValue] {
-    case "Yes" => FuzzyValue.Yes
-    case "No" => FuzzyValue.No
+    case "Yes"   => FuzzyValue.Yes
+    case "No"    => FuzzyValue.No
     case "Maybe" => FuzzyValue.Maybe
     case x =>
       Option(x).fold {
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala b/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala
index edef2eb..a3140a6 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala
@@ -8,7 +8,7 @@ import scala.concurrent.Future
 trait BridgeUploadQueueRepository extends Repository {
 
   type EntityT = BridgeUploadQueue.Item
-  type IdT = LongId[EntityT]
+  type IdT     = LongId[EntityT]
 
   def add(draft: EntityT): EntityT