Fixing scalafmt configuration (#14)

* Fix sbt build for scalafmt config

* Tuning scalafmt config

* Reformatting method definition

* Update formatter conf for alignment

Author: stankoua

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+# All files
+insert_final_newline = true
+
+# 2 spaces indentation
+[*.scala, *.sbt]
+indent_style = space
+indent_size = 2

build.sbt

@@ -37,20 +37,25 @@ val commonSettings = Seq(
     Set(
       "-Ywarn-unused:imports",
       "-Xfatal-warnings"
-    ))),
+    )
+  )),
   scalacOptions in (Test, compile) ~= (_.filterNot(
     Set(
       "-Ywarn-unused:imports",
       "-Xfatal-warnings",
       "-Yrangepos"
-    ))),
+    )
+  )),
   resolvers ++= Seq[Resolver](
     Resolver.sonatypeRepo("releases")
   )
 )
 
+scalafmtOnCompile in ThisBuild := true
 scalafmtOnCompile := true
-scalafmtConfig := file("project/scalafmt.conf")
+scalafmtTestOnCompile in ThisBuild := true
+scalafmtTestOnCompile := true
+scalafmtConfig in ThisBuild := file("project/scalafmt.conf")
 
 wartremoverErrors ++= Warts.unsafe
 
@@ -62,7 +67,7 @@ lazy val core = (project in file("core"))
     name := "query-core",
     libraryDependencies ++= Seq(
       Dependencies.acolyte % Test,
-      Dependencies.anorm % Test,
+      Dependencies.anorm   % Test,
       Dependencies.cats,
       Dependencies.specs2 % Test
     )

core/src/main/scala/core/database/ComposeWithCompletion.scala

@@ -4,13 +4,14 @@ import scala.concurrent.{ExecutionContext, Future}
 import scala.language.higherKinds
 
 /**
-  * Heavily inspired from work done by @cchantep in Acolyte (see acolyte.reactivemongo.ComposeWithCompletion)
-  */
+ * Heavily inspired from work done by @cchantep in Acolyte (see acolyte.reactivemongo.ComposeWithCompletion)
+ */
 trait ComposeWithCompletion[F[_], Out] {
   type Outer <: Future[_]
 
   def apply[In](resource: In, f: In => F[Out])(onComplete: In => Unit)(
-      implicit ec: ExecutionContext): Outer
+      implicit ec: ExecutionContext
+  ): Outer
 }
 
 object ComposeWithCompletion extends LowPriorityCompose {
@@ -21,8 +22,9 @@ object ComposeWithCompletion extends LowPriorityCompose {
     new ComposeWithCompletion[Future, A] {
       type Outer = Future[A]
 
-      def apply[In](resource: In, f: In => Future[A])(onComplete: In => Unit)(
-          implicit ec: ExecutionContext): Outer =
+      def apply[In](resource: In, f: In => Future[A])(
+          onComplete: In => Unit
+      )(implicit ec: ExecutionContext): Outer =
         f(resource).andThen {
           case _ => onComplete(resource)
         }
@@ -38,8 +40,9 @@ trait LowPriorityCompose { _: ComposeWithCompletion.type =>
     new ComposeWithCompletion[F, A] {
       type Outer = Future[F[A]]
 
-      def apply[In](resource: In, f: In => F[A])(onComplete: In => Unit)(
-          implicit ec: ExecutionContext): Outer =
+      def apply[In](resource: In, f: In => F[A])(
+          onComplete: In => Unit
+      )(implicit ec: ExecutionContext): Outer =
         Future(f(resource)).andThen { case _ => onComplete(resource) }
 
       override val toString = "pureOut"

core/src/main/scala/core/database/QueryRunner.scala

@@ -4,28 +4,22 @@ import scala.concurrent.ExecutionContext
 import scala.language.higherKinds
 
 /**
-  * A class who can run a Query.
-  */
+ * A class who can run a Query.
+ */
 sealed trait QueryRunner[Resource] {
-  def apply[M[_], T](
-      query: QueryT[M, Resource, T]
-  )(
+  def apply[M[_], T](query: QueryT[M, Resource, T])(
       implicit compose: ComposeWithCompletion[M, T]
   ): compose.Outer
 }
 
 object QueryRunner {
-  private class DefaultRunner[Resource](
-      wr: WithResource[Resource]
-  )(
+  private class DefaultRunner[Resource](wr: WithResource[Resource])(
       implicit ec: ExecutionContext
   ) extends QueryRunner[Resource] {
 
     def apply[M[_], T](
         query: QueryT[M, Resource, T]
-    )(
-        implicit compose: ComposeWithCompletion[M, T]
-    ): compose.Outer = {
+    )(implicit compose: ComposeWithCompletion[M, T]): compose.Outer = {
       wr { resource =>
         compose(resource, query.run)(wr.releaseIfNecessary)
       }
@@ -36,8 +30,6 @@ object QueryRunner {
   // Default factory
   def apply[Resource](
       wr: WithResource[Resource]
-  )(
-      implicit ec: ExecutionContext
-  ): QueryRunner[Resource] =
+  )(implicit ec: ExecutionContext): QueryRunner[Resource] =
     new DefaultRunner(wr)
 }

core/src/main/scala/core/module/sql/package.scala

@@ -9,10 +9,10 @@ import cats.Applicative
 
 import com.zengularity.querymonad.core.database.{
   Query,
+  QueryE,
+  QueryO,
   QueryRunner,
   QueryT,
-  QueryO,
-  QueryE,
   WithResource
 }
 
@@ -57,8 +57,9 @@ package object sql {
   type SqlQueryRunner = QueryRunner[Connection]
 
   object SqlQueryRunner {
-    def apply(wc: WithSqlConnection)(
-        implicit ec: ExecutionContext): SqlQueryRunner =
+    def apply(
+        wc: WithSqlConnection
+    )(implicit ec: ExecutionContext): SqlQueryRunner =
       QueryRunner[Connection](wc)
   }
 

core/src/test/scala/module/sql/SqlQueryRunnerSpec.scala

@@ -11,8 +11,8 @@ import org.specs2.mutable.Specification
 
 import com.zengularity.querymonad.core.module.sql.{
   SqlQuery,
-  SqlQueryT,
   SqlQueryRunner,
+  SqlQueryT,
   WithSqlConnection
 }
 import com.zengularity.querymonad.test.core.module.sql.models.{
@@ -51,7 +51,8 @@ class SqlQueryRunnerSpec(implicit ee: ExecutionEnv) extends Specification {
       val result = runner(Professor.fetchProfessor(1)).map(_.get)
 
       result aka "professor" must beTypedEqualTo(
-        Professor(1, "John Doe", 35, 1)).await
+        Professor(1, "John Doe", 35, 1)
+      ).await
     }
 
     "retrieve material with id 1" in {
@@ -61,15 +62,16 @@ class SqlQueryRunnerSpec(implicit ee: ExecutionEnv) extends Specification {
       val result = runner(Material.fetchMaterial(1)).map(_.get)
 
       result aka "material" must beTypedEqualTo(
-        Material(1, "Computer Science", 20, "Beginner")).await
+        Material(1, "Computer Science", 20, "Beginner")
+      ).await
     }
 
     "not retrieve professor with id 2" in {
       val withSqlConnection: WithSqlConnection =
         SqlConnectionFactory.withSqlConnection(AcolyteQueryResult.Nil)
       val runner = SqlQueryRunner(withSqlConnection)
       val query = for {
-        _ <- SqlQuery.ask
+        _         <- SqlQuery.ask
         professor <- Professor.fetchProfessor(2)
       } yield professor
 
@@ -93,12 +95,13 @@ class SqlQueryRunnerSpec(implicit ee: ExecutionEnv) extends Specification {
       val runner = SqlQueryRunner(withSqlConnection)
       val query = for {
         professor <- Professor.fetchProfessor(1).map(_.get)
-        material <- Material.fetchMaterial(professor.material).map(_.get)
+        material  <- Material.fetchMaterial(professor.material).map(_.get)
       } yield (professor, material)
 
       runner(query) aka "professor and material" must beTypedEqualTo(
         Tuple2(Professor(1, "John Doe", 35, 1),
-               Material(1, "Computer Science", 20, "Beginner"))).await
+               Material(1, "Computer Science", 20, "Beginner"))
+      ).await
     }
 
     "not retrieve professor with id 1 and no material" in {
@@ -115,7 +118,8 @@ class SqlQueryRunnerSpec(implicit ee: ExecutionEnv) extends Specification {
       val query = for {
         professor <- SqlQueryT.fromQuery(Professor.fetchProfessor(1))
         material <- SqlQueryT.fromQuery(
-          Material.fetchMaterial(professor.material))
+          Material.fetchMaterial(professor.material)
+        )
       } yield (professor, material)
 
       runner(query) aka "professor and material" must beNone.await

core/src/test/scala/module/sql/models/Material.scala

@@ -11,9 +11,9 @@ case class Material(id: Int, name: String, numberOfHours: Int, level: String)
 
 object Material {
   val schema = rowList4(
-    classOf[Int] -> "id",
+    classOf[Int]    -> "id",
     classOf[String] -> "name",
-    classOf[Int] -> "numberOfHours",
+    classOf[Int]    -> "numberOfHours",
     classOf[String] -> "level"
   )
 

core/src/test/scala/module/sql/models/Professor.scala

@@ -11,10 +11,10 @@ case class Professor(id: Int, name: String, age: Int, material: Int)
 
 object Professor {
   val schema = rowList4(
-    classOf[Int] -> "id",
+    classOf[Int]    -> "id",
     classOf[String] -> "name",
-    classOf[Int] -> "age",
-    classOf[Int] -> "material"
+    classOf[Int]    -> "age",
+    classOf[Int]    -> "material"
   )
 
   val parser = Macro.namedParser[Professor]

core/src/test/scala/module/sql/utils/SqlConnectionFactory.scala

@@ -13,7 +13,8 @@ import com.zengularity.querymonad.core.module.sql.WithSqlConnection
 object SqlConnectionFactory {
 
   def withSqlConnection[A <: AcolyteQueryResult](
-      resultsSet: A): WithSqlConnection =
+      resultsSet: A
+  ): WithSqlConnection =
     new WithSqlConnection {
       def apply[B](f: Connection => B): B =
         AcolyteDSL.withQueryResult(resultsSet)(f)

examples/sample-app/app/wiring/AppLoader.scala

@@ -12,8 +12,8 @@ import play.api.routing.sird._
 
 import com.zengularity.querymonad.core.module.sql.{
   SqlQuery,
-  SqlQueryT,
-  SqlQueryRunner
+  SqlQueryRunner,
+  SqlQueryT
 }
 import com.zengularity.querymonad.examples.database.WithPlayTransaction
 
@@ -45,7 +45,8 @@ class AppComponents(context: Context)
             Future {
               Thread.sleep(2000) // Simumlates a a very slow query
               SQL"select sqrt($num) as result".as(
-                SqlParser.double("result").single)
+                SqlParser.double("result").single
+              )
             }
           }
 
@@ -57,8 +58,10 @@ class AppComponents(context: Context)
         val query =
           for {
             number <- SqlQuery.pure(42)
-            text <- SqlQuery(implicit c =>
-              SQL"select $cmd as result".as(SqlParser.str("result").single))
+            text <- SqlQuery(
+              implicit c =>
+                SQL"select $cmd as result".as(SqlParser.str("result").single)
+            )
           } yield (text + number)
 
         queryRunner(query).map(r => Ok(r.toString))