Merge pull request #557 from yadavan88/scalafmt-styling

Scalafmt on the entire project

Author: lor6

.scalafmt.conf

@@ -1,5 +1,10 @@
-version = 3.5.9
-runner.dialect = scala3
+version = 3.7.1
+runner.dialect = scala213
+fileOverride {
+  "glob:**/scala3-*/**" {
+    runner.dialect = scala3
+  }
+}
 continuationIndent.defnSite = 2
 continuationIndent.ctorSite = 2
 continuationIndent.extendSite = 2

cats-effects/src/main/scala/com/baeldung/scala/catseffects/LazyIO.scala

@@ -2,8 +2,9 @@ package com.baeldung.scala.catseffects
 
 case class LazyIO[A](runEffect: () => A) {
   def map[B](fn: A => B): LazyIO[B] = LazyIO.io(fn(runEffect()))
-  
-  def flatMap[B](fn: A => LazyIO[B]): LazyIO[B] = LazyIO.io(fn(runEffect()).runEffect())
+
+  def flatMap[B](fn: A => LazyIO[B]): LazyIO[B] =
+    LazyIO.io(fn(runEffect()).runEffect())
 }
 
 object LazyIO {

cats-effects/src/main/scala/com/baeldung/scala/catseffects/MissileLaucher.scala

@@ -4,11 +4,12 @@ import cats.effect.{ExitCode, IO, IOApp}
 
 object MissileLaucher extends IOApp {
   def putStr(str: String): IO[Unit] = IO.delay(println(str))
-  
+
   val launch: IO[Unit] = for {
     _ <- putStr("Lauch missiles")
     _ <- putStr("Lauch missiles")
   } yield ()
-  
-  override def run(args: List[String]): IO[ExitCode] = launch.as(ExitCode.Success)
+
+  override def run(args: List[String]): IO[ExitCode] =
+    launch.as(ExitCode.Success)
 }

cats-effects/src/main/scala/com/baeldung/scala/catseffects/NotParallelApp.scala

@@ -7,12 +7,13 @@ import com.baeldung.scala.catseffects.Utils.ShowThread
 object NotParallelApp extends IOApp {
   val tasks: List[IO[Int]] = (1 to 10).map(IO.pure).map(_.showThread).toList
 
-  val incremented: IO[List[Int]] = tasks.traverse {
-    ioi => for (i <- ioi) yield i + 1
+  val incremented: IO[List[Int]] = tasks.traverse { ioi =>
+    for (i <- ioi) yield i + 1
   }
-  
+
   val parallelOrNot: IO[List[Int]] = incremented.showThread
-  
-  override def run(args: List[String]): IO[ExitCode] = parallelOrNot.as(ExitCode.Success)
-  
+
+  override def run(args: List[String]): IO[ExitCode] =
+    parallelOrNot.as(ExitCode.Success)
+
 }

cats-effects/src/main/scala/com/baeldung/scala/catseffects/ParallelApp.scala

@@ -7,11 +7,12 @@ import com.baeldung.scala.catseffects.Utils.ShowThread
 object ParallelApp extends IOApp {
   val tasks: List[IO[Int]] = (1 to 10).map(IO.pure).map(_.showThread).toList
 
-  val incremented: IO[List[Int]] = tasks.parTraverse {
-    ioi => for (i <- ioi) yield i + 1
+  val incremented: IO[List[Int]] = tasks.parTraverse { ioi =>
+    for (i <- ioi) yield i + 1
   }
 
   val parallelOrNot: IO[List[Int]] = incremented.showThread
 
-  override def run(args: List[String]): IO[ExitCode] = parallelOrNot.as(ExitCode.Success)
+  override def run(args: List[String]): IO[ExitCode] =
+    parallelOrNot.as(ExitCode.Success)
 }

cats-effects/src/main/scala/com/baeldung/scala/catseffects/SequenceApp.scala

@@ -8,7 +8,9 @@ object SequenceApp extends IOApp {
 
   val tasks: List[IO[Int]] = (1 to 1000).map(IO.pure).toList
   val sequenceAllTasks: IO[List[Int]] = tasks.sequence
-  val printTaskSequence: IO[Unit] = sequenceAllTasks.map(_.mkString(", ")).flatMap(putStr)
-  
-  override def run(args: List[String]): IO[ExitCode] = sequenceAllTasks.as(ExitCode.Success)
+  val printTaskSequence: IO[Unit] =
+    sequenceAllTasks.map(_.mkString(", ")).flatMap(putStr)
+
+  override def run(args: List[String]): IO[ExitCode] =
+    sequenceAllTasks.as(ExitCode.Success)
 }

cats-effects/src/main/scala/com/baeldung/scala/catseffects/Substitution.scala

@@ -11,8 +11,10 @@ object Substitution {
   }
 
   def effectfulWithFuture(): Unit = {
-    implicit val ec: ExecutionContextExecutor = ExecutionContext.global 
-    Future(println("Launch missiles")).map(_ => Future(println("Launch missiles")))
+    implicit val ec: ExecutionContextExecutor = ExecutionContext.global
+    Future(println("Launch missiles")).map(_ =>
+      Future(println("Launch missiles"))
+    )
   }
 
   def effectfulWithFutureRefactored(): Unit = {

cats-effects/src/main/scala/com/baeldung/scala/catseffects/TraverseApp.scala

@@ -9,6 +9,7 @@ object TraverseApp extends IOApp {
   val tasks: List[Int] = (1 to 1000).toList
   def taskExecutor(i: Int): String = s"Executing task $i"
   val runAllTasks: IO[List[Unit]] = tasks.traverse(i => putStr(taskExecutor(i)))
-  
-  override def run(args: List[String]): IO[ExitCode] = runAllTasks.as(ExitCode.Success)
+
+  override def run(args: List[String]): IO[ExitCode] =
+    runAllTasks.as(ExitCode.Success)
 }

cats-effects/src/main/scala/com/baeldung/scala/catseffects/Utils.scala

@@ -5,7 +5,7 @@ import cats.effect.IO
 object Utils {
   implicit class ShowThread[T](io: IO[T]) {
     def showThread: IO[T] = for {
-      thunk <- io 
+      thunk <- io
       thread = Thread.currentThread.getName
       _ = println(s"[$thread] $thunk")
     } yield thunk

cats-effects/src/main/scala/com/baeldung/scala/differences/Differences.scala

@@ -11,10 +11,10 @@ object Differences extends IOApp.Simple {
 
   val delayedDurationIO = io.delayBy(3.seconds)
 
-  //This will fail with Stackoverflow Exception
+  // This will fail with Stackoverflow Exception
   def neverEnding(io: IO[Int]): IO[Unit] = { io *> neverEnding(io) }
 
-  //This will run forever without any StackOverflowException
+  // This will run forever without any StackOverflowException
   def neverEndingV2(io: IO[Int]): IO[Unit] = {
     io *> IO.defer(neverEndingV2(io))
   }

cats-effects/src/main/scala/com/baeldung/scala/differences/FlatEvalDiff.scala

@@ -4,33 +4,37 @@ import cats.effect.{IO, IOApp, Resource}
 
 object FlatEvalDiff extends IOApp.Simple {
 
-  val strIO = IO("This is a string IO")  
-  
+  val strIO = IO("This is a string IO")
+
   def countLetters(str: String): IO[Int] = IO(str.length())
 
   val countIO: IO[Int] = strIO.flatMap(s => countLetters(s))
 
   def countLettersWithPrint(str: String): IO[Unit] = IO {
-    println("String length is "+str.length())
+    println("String length is " + str.length())
   }
   val flatTapIO: IO[String] = strIO.flatTap(countLettersWithPrint)
 
-  val flatTapIO_V2: IO[String] = strIO.map{r => 
+  val flatTapIO_V2: IO[String] = strIO.map { r =>
     countLettersWithPrint(r)
     r
   }
 
   case class SimpleConnection(url: String)
   case class ComplexConnection(url: String)
   def acquireResource(): IO[SimpleConnection] = {
-    IO.println("Opening Simple Connection") >> IO(SimpleConnection("localhost:8000")) 
+    IO.println("Opening Simple Connection") >> IO(
+      SimpleConnection("localhost:8000")
+    )
   }
   def releaseResource(con: SimpleConnection): IO[Unit] = {
-    IO.println("Closing Simple Connection: "+con.url)
+    IO.println("Closing Simple Connection: " + con.url)
   }
-  
-  val resource: Resource[IO,SimpleConnection] = Resource.make(acquireResource)(releaseResource)
-  val simpleResourceData: IO[Unit] = resource.use(simpleConn => IO.println("Result using Simple Resource"))
+
+  val resource: Resource[IO, SimpleConnection] =
+    Resource.make(acquireResource)(releaseResource)
+  val simpleResourceData: IO[Unit] =
+    resource.use(simpleConn => IO.println("Result using Simple Resource"))
 
   def transformConnection(con: SimpleConnection) = {
     IO {
@@ -39,13 +43,18 @@ object FlatEvalDiff extends IOApp.Simple {
     }
   }
 
-  val modifiedResource: Resource[IO,ComplexConnection] = resource.evalMap(con => transformConnection(con))
-  val tappedResource: Resource[IO,SimpleConnection] = resource.evalTap(con => transformConnection(con))
-
-  val evalTapRes: IO[Unit] = tappedResource.use(simple => IO.println("Using simple connection from evalTap to execute.."))
-  val evalMapRes: IO[Unit] = modifiedResource.use(complex => IO.println("Using complex connection from evalMap to execute.."))
+  val modifiedResource: Resource[IO, ComplexConnection] =
+    resource.evalMap(con => transformConnection(con))
+  val tappedResource: Resource[IO, SimpleConnection] =
+    resource.evalTap(con => transformConnection(con))
 
+  val evalTapRes: IO[Unit] = tappedResource.use(simple =>
+    IO.println("Using simple connection from evalTap to execute..")
+  )
+  val evalMapRes: IO[Unit] = modifiedResource.use(complex =>
+    IO.println("Using complex connection from evalMap to execute..")
+  )
 
   override def run: IO[Unit] = evalTapRes
 
-}
+}

cats-effects/src/main/scala/com/baeldung/scala/fibers/Fibers.scala

@@ -30,8 +30,9 @@ object Fibers extends IOApp.Simple {
 
   val outcome: IO[String] = fibCancel.flatMap {
     case Outcome.Succeeded(fa) => IO("fiber executed successfully").printIO
-    case Outcome.Errored(e)    => IO("error occurred during fiber execution").printIO
-    case Outcome.Canceled()    => IO("fiber was canceled!").printIO
+    case Outcome.Errored(e) =>
+      IO("error occurred during fiber execution").printIO
+    case Outcome.Canceled() => IO("fiber was canceled!").printIO
   }
 
   val ioWithCancelationHook =
@@ -67,7 +68,10 @@ object Fibers extends IOApp.Simple {
 
   val ioWithTimeout: IO[String] = participant1.timeout(400.millis)
 
-  val ioWithFallback = participant1.timeoutTo(400.millis, IO("Fallback IO executed after timeout").printIO)
+  val ioWithFallback = participant1.timeoutTo(
+    400.millis,
+    IO("Fallback IO executed after timeout").printIO
+  )
 
   override def run: IO[Unit] = ioWithFallback.void
 }

doobie/src/main/scala/com/baeldung/scala/doobie/DoobieFragments.scala

@@ -16,15 +16,20 @@ object DoobieFragments extends IOApp.Simple {
 
     import doobie.Fragments._
     val optionalCityNameParam: Option[String] = Some("%Pol%")
-    val optionalCityNameFragment: Option[Fragment] = optionalCityNameParam.map(name => fr"name like $name")
+    val optionalCityNameFragment: Option[Fragment] =
+      optionalCityNameParam.map(name => fr"name like $name")
     val limitFragment = fr"limit 5"
 
     (for {
-      selectedCities <- (fr"select name from city" ++ whereAndOpt(optionalCityNameFragment)).query[String].to[List]
-      selectedLimitedCities <- (fr"select name from city" ++ limitFragment).query[String].to[List]
-    } yield (selectedCities, selectedLimitedCities)).transact(transactor).map { tuple =>
-      println(s"fragment results: $tuple")
+      selectedCities <- (fr"select name from city" ++ whereAndOpt(
+        optionalCityNameFragment
+      )).query[String].to[List]
+      selectedLimitedCities <- (fr"select name from city" ++ limitFragment)
+        .query[String]
+        .to[List]
+    } yield (selectedCities, selectedLimitedCities)).transact(transactor).map {
+      tuple =>
+        println(s"fragment results: $tuple")
     }
   }
 }
-

doobie/src/main/scala/com/baeldung/scala/doobie/DoobieQuickStart.scala

@@ -5,7 +5,13 @@ import doobie.implicits._
 import doobie.{ConnectionIO, Transactor}
 
 // Equivalent to world db city table
-case class City(id: Long, name: String, countryCode: String, district: String, population: Int)
+case class City(
+  id: Long,
+  name: String,
+  countryCode: String,
+  district: String,
+  population: Int
+)
 
 object DoobieQuickStart extends IOApp.Simple {
 
@@ -18,26 +24,29 @@ object DoobieQuickStart extends IOApp.Simple {
     )
 
     val operations: ConnectionIO[Unit] = for {
-      someCities <- sql"select id, name, country_code, district, population from city limit 5"
-        .query[City]
-        .to[List]
+      someCities <-
+        sql"select id, name, country_code, district, population from city limit 5"
+          .query[City]
+          .to[List]
       _ = println(s"Selected some cities: $someCities")
       baeldungCity = City(5000, "Baeldung", "NLD", "Baeldungland", 1337)
-      insertedId <- sql"insert into city (id, name, country_code, district, population) values (${baeldungCity.id}, ${baeldungCity.name}, ${baeldungCity.countryCode}, ${baeldungCity.district}, ${baeldungCity.population})"
-        .update
-        .withUniqueGeneratedKeys[Int]("id")
+      insertedId <-
+        sql"insert into city (id, name, country_code, district, population) values (${baeldungCity.id}, ${baeldungCity.name}, ${baeldungCity.countryCode}, ${baeldungCity.district}, ${baeldungCity.population})".update
+          .withUniqueGeneratedKeys[Int]("id")
       _ = println(s"Inserted baeldung city: $insertedId")
-      selectedCity <- sql"select id, name, country_code, district, population from city where id = $insertedId"
-        .query[City]
-        .unique
+      selectedCity <-
+        sql"select id, name, country_code, district, population from city where id = $insertedId"
+          .query[City]
+          .unique
       _ = println(s"Selected baeldung city: $selectedCity")
-      updatedName <- sql"update city set name = 'DungBael' where id = 5000"
-        .update
-        .withUniqueGeneratedKeys[String]("name")
-      _ = println(s"Updated baeldung city: ${baeldungCity.name} -> $updatedName")
-      deletedRows <- sql"delete from city where id = ${baeldungCity.id}"
-        .update
-        .run
+      updatedName <-
+        sql"update city set name = 'DungBael' where id = 5000".update
+          .withUniqueGeneratedKeys[String]("name")
+      _ = println(
+        s"Updated baeldung city: ${baeldungCity.name} -> $updatedName"
+      )
+      deletedRows <-
+        sql"delete from city where id = ${baeldungCity.id}".update.run
       _ = println(s"Deleted baeldung city: $deletedRows")
     } yield ()
 

reflection/src/main/scala/com/baeldung/reflection/Person.scala

@@ -8,6 +8,6 @@ case class Person(name: String, age: Int) extends PersonInterface {
        |  age: $age
        |}
        |""".stripMargin
-  
+
   private val password = "123"
 }

reflection/src/test/scala/com/baeldung/reflection/JavaReflectionTest.scala

@@ -7,8 +7,9 @@ class JavaReflectionTest {
   def invoke_method_dynamically(): Unit = {
     val person = Person("John", 20)
     val result = classOf[Person].getDeclaredMethod("prettyPrint").invoke(person)
-    assert(result ==
-      s"""
+    assert(
+      result ==
+        s"""
          |Person {
          |  name: "John",
          |  age: 20