Action sbt scalafmtAll

takapi327 · Jan 2, 2025 · 772cef5 · 772cef5
1 parent a96c09d
commit 772cef5
Showing 1 changed file with 33 additions and 27 deletions.
diff --git a/module/ldbc-dsl/src/main/scala/ldbc/dsl/DBIO.scala b/module/ldbc-dsl/src/main/scala/ldbc/dsl/DBIO.scala
@@ -63,7 +63,7 @@ object DBIO:
   private[ldbc] case class Impl[F[_]: Temporal, T](
     statement: String,
     params:    List[Parameter],
-    func:       Connection[F] => F[T]
+    func:      Connection[F] => F[T]
   ) extends DBIO[F, T]:
 
     override def run(connection: Connection[F])(using logHandler: LogHandler[F]): F[T] =
@@ -78,16 +78,17 @@ object DBIO:
       connection.setReadOnly(false) *> connection.setAutoCommit(true) *> run(connection)
 
     override def rollback(connection: Connection[F])(using LogHandler[F]): F[T] =
-      connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection.rollback() <* connection.setAutoCommit(true)
+      connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection
+        .rollback() <* connection.setAutoCommit(true)
 
     override def transaction(connection: Connection[F])(using LogHandler[F]): F[T] =
       val acquire = connection.setReadOnly(false) *> connection.setAutoCommit(false) *> Temporal[F].pure(connection)
 
       val release = (connection: Connection[F], exitCase: ExitCase) =>
         (exitCase match
           case ExitCase.Errored(_) | ExitCase.Canceled => connection.rollback()
-          case _ => connection.commit()
-          )
+          case _                                       => connection.commit()
+        )
           *> connection.setAutoCommit(true)
 
       Resource
@@ -96,39 +97,41 @@ object DBIO:
 
   def pure[F[_]: Monad, A](value: A): DBIO[F, A] =
     new DBIO[F, A]:
-      override def run(connection: Connection[F])(using logHandler: LogHandler[F]): F[A] = Monad[F].pure(value)
-      override def readOnly(connection:              Connection[F])(using LogHandler[F]): F[A] = Monad[F].pure(value)
-      override def commit(connection:                Connection[F])(using LogHandler[F]): F[A] = Monad[F].pure(value)
-      override def rollback(connection:              Connection[F])(using LogHandler[F]): F[A] = Monad[F].pure(value)
-      override def transaction(connection:           Connection[F])(using LogHandler[F]): F[A] = Monad[F].pure(value)
+      override def run(connection:         Connection[F])(using logHandler: LogHandler[F]): F[A] = Monad[F].pure(value)
+      override def readOnly(connection:    Connection[F])(using LogHandler[F]):             F[A] = Monad[F].pure(value)
+      override def commit(connection:      Connection[F])(using LogHandler[F]):             F[A] = Monad[F].pure(value)
+      override def rollback(connection:    Connection[F])(using LogHandler[F]):             F[A] = Monad[F].pure(value)
+      override def transaction(connection: Connection[F])(using LogHandler[F]):             F[A] = Monad[F].pure(value)
 
   def raiseError[F[_], A](e: Throwable)(using ev: MonadThrow[F]): DBIO[F, A] =
     new DBIO[F, A]:
-      override def run(connection: Connection[F])(using logHandler: LogHandler[F]): F[A] = ev.raiseError(e)
-      override def readOnly(connection: Connection[F])(using LogHandler[F]): F[A] = ev.raiseError(e)
-      override def commit(connection: Connection[F])(using LogHandler[F]): F[A] = ev.raiseError(e)
-      override def rollback(connection: Connection[F])(using LogHandler[F]): F[A] = ev.raiseError(e)
-      override def transaction(connection: Connection[F])(using LogHandler[F]): F[A] = ev.raiseError(e)
+      override def run(connection:         Connection[F])(using logHandler: LogHandler[F]): F[A] = ev.raiseError(e)
+      override def readOnly(connection:    Connection[F])(using LogHandler[F]):             F[A] = ev.raiseError(e)
+      override def commit(connection:      Connection[F])(using LogHandler[F]):             F[A] = ev.raiseError(e)
+      override def rollback(connection:    Connection[F])(using LogHandler[F]):             F[A] = ev.raiseError(e)
+      override def transaction(connection: Connection[F])(using LogHandler[F]):             F[A] = ev.raiseError(e)
 
   given [F[_]: Temporal]: MonadError[[T] =>> DBIO[F, T], Throwable] with
     override def pure[A](x: A): DBIO[F, A] = DBIO.pure(x)
 
     override def flatMap[A, B](fa: DBIO[F, A])(f: A => DBIO[F, B]): DBIO[F, B] =
       new DBIO[F, B]:
-        override def run(connection: Connection[F])(using logHandler: LogHandler[F]): F[B] = fa.run(connection).flatMap(a => f(a).run(connection))
+        override def run(connection: Connection[F])(using logHandler: LogHandler[F]): F[B] =
+          fa.run(connection).flatMap(a => f(a).run(connection))
         override def readOnly(connection: Connection[F])(using LogHandler[F]): F[B] =
           connection.setReadOnly(true) *> run(connection) <* connection.setReadOnly(false)
         override def commit(connection: Connection[F])(using LogHandler[F]): F[B] =
           connection.setReadOnly(false) *> connection.setAutoCommit(true) *> run(connection)
         override def rollback(connection: Connection[F])(using LogHandler[F]): F[B] =
-          connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection.rollback() <* connection.setAutoCommit(true)
+          connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection
+            .rollback() <* connection.setAutoCommit(true)
         override def transaction(connection: Connection[F])(using LogHandler[F]): F[B] =
           val acquire = connection.setReadOnly(false) *> connection.setAutoCommit(false) *> Temporal[F].pure(connection)
           val release = (connection: Connection[F], exitCase: ExitCase) =>
             (exitCase match
               case ExitCase.Errored(_) | ExitCase.Canceled => connection.rollback()
-              case _ => connection.commit()
-              )
+              case _                                       => connection.commit()
+            )
               *> connection.setAutoCommit(true)
           Resource
             .makeCase(acquire)(release)
@@ -146,16 +149,17 @@ object DBIO:
           connection.setReadOnly(false) *> connection.setAutoCommit(true) *> run(connection)
 
         override def rollback(connection: Connection[F])(using LogHandler[F]): F[B] =
-          connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection.rollback() <* connection.setAutoCommit(true)
+          connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection
+            .rollback() <* connection.setAutoCommit(true)
 
         override def transaction(connection: Connection[F])(using LogHandler[F]): F[B] =
           val acquire = connection.setReadOnly(false) *> connection.setAutoCommit(false) *> Temporal[F].pure(connection)
 
           val release = (connection: Connection[F], exitCase: ExitCase) =>
             (exitCase match
               case ExitCase.Errored(_) | ExitCase.Canceled => connection.rollback()
-              case _ => connection.commit()
-              )
+              case _                                       => connection.commit()
+            )
               *> connection.setAutoCommit(true)
 
           Resource
@@ -174,16 +178,17 @@ object DBIO:
           connection.setReadOnly(false) *> connection.setAutoCommit(true) *> run(connection)
 
         override def rollback(connection: Connection[F])(using LogHandler[F]): F[B] =
-          connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection.rollback() <* connection.setAutoCommit(true)
+          connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection
+            .rollback() <* connection.setAutoCommit(true)
 
         override def transaction(connection: Connection[F])(using LogHandler[F]): F[B] =
           val acquire = connection.setReadOnly(false) *> connection.setAutoCommit(false) *> Temporal[F].pure(connection)
 
           val release = (connection: Connection[F], exitCase: ExitCase) =>
             (exitCase match
               case ExitCase.Errored(_) | ExitCase.Canceled => connection.rollback()
-              case _ => connection.commit()
-              )
+              case _                                       => connection.commit()
+            )
               *> connection.setAutoCommit(true)
 
           Resource
@@ -205,16 +210,17 @@ object DBIO:
           connection.setReadOnly(false) *> connection.setAutoCommit(true) *> run(connection)
 
         override def rollback(connection: Connection[F])(using LogHandler[F]): F[A] =
-          connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection.rollback() <* connection.setAutoCommit(true)
+          connection.setReadOnly(false) *> connection.setAutoCommit(false) *> run(connection) <* connection
+            .rollback() <* connection.setAutoCommit(true)
 
         override def transaction(connection: Connection[F])(using LogHandler[F]): F[A] =
           val acquire = connection.setReadOnly(false) *> connection.setAutoCommit(false) *> Temporal[F].pure(connection)
 
           val release = (connection: Connection[F], exitCase: ExitCase) =>
             (exitCase match
               case ExitCase.Errored(_) | ExitCase.Canceled => connection.rollback()
-              case _ => connection.commit()
-              )
+              case _                                       => connection.commit()
+            )
               *> connection.setAutoCommit(true)
 
           Resource