Apply scalafmt formatting

Author: migesok

build.sbt

@@ -6,7 +6,7 @@ lazy val modules: List[ProjectReference] = List(
   `stracer`,
   `stracer-play-json`,
   `stracer-circe`,
-  `stracer-kafka`
+  `stracer-kafka`,
 )
 
 lazy val root = project
@@ -30,21 +30,26 @@ lazy val `stracer` = project
       CatsEffect.effect,
       configTools,
       Pureconfig.pureconfig,
-      scalatest % Test))
+      scalatest % Test,
+    ),
+  )
 
 lazy val `stracer-play-json` = project
   .dependsOn(`stracer`)
   .settings(commonSettings)
   .settings(
     libraryDependencies ++= Seq(
       PlayJsonTools.tools,
-      scalatest % Test))
+      scalatest % Test,
+    ),
+  )
 
 lazy val `stracer-circe` = project
   .dependsOn(`stracer`)
   .settings(commonSettings)
   .settings(
-    libraryDependencies ++= Circe.all ++ Seq(scalatest % Test))
+    libraryDependencies ++= Circe.all ++ Seq(scalatest % Test),
+  )
 
 lazy val `stracer-kafka` = project
   .dependsOn(`stracer`)
@@ -63,11 +68,11 @@ val commonSettings = Seq(
   releaseCrossBuild := true,
   licenses := Seq(("MIT", url("https://opensource.org/licenses/MIT"))),
   publishTo := Some(Resolver.evolutionReleases),
-  scalacOptsFailOnWarn := Some(false))
+  scalacOptsFailOnWarn := Some(false),
+)
 
 val alias: Seq[sbt.Def.Setting[?]] =
   //  addCommandAlias("check", "all versionPolicyCheck Compile/doc") ++
   addCommandAlias("check", "all Compile/doc scalafmtCheckAll scalafmtSbtCheck") ++
     addCommandAlias("build", "+all compile test") ++
     addCommandAlias("fmt", "+all scalafmtAll scalafmtSbt")
-

project/Dependencies.scala

@@ -2,13 +2,12 @@ import sbt._
 
 object Dependencies {
 
-  val scalatest     = "org.scalatest"       %% "scalatest"    % "3.2.15"
-  val zipkin        = "io.zipkin.zipkin2"   % "zipkin"        % "2.21.6"
-  val `cats-helper` = "com.evolutiongaming" %% "cats-helper"  % "3.5.0"
-  val random        = "com.evolutiongaming" %% "random"       % "1.0.0"
-  val configTools   = "com.evolutiongaming" %% "config-tools" % "1.0.4"
-  val skafka        = "com.evolutiongaming" %% "skafka"       % "17.1.2"
-
+  val scalatest = "org.scalatest" %% "scalatest" % "3.2.15"
+  val zipkin = "io.zipkin.zipkin2" % "zipkin" % "2.21.6"
+  val `cats-helper` = "com.evolutiongaming" %% "cats-helper" % "3.5.0"
+  val random = "com.evolutiongaming" %% "random" % "1.0.0"
+  val configTools = "com.evolutiongaming" %% "config-tools" % "1.0.4"
+  val skafka = "com.evolutiongaming" %% "skafka" % "17.1.2"
 
   object Cats {
     private val version = "2.8.0"
@@ -28,24 +27,24 @@ object Dependencies {
   object PlayJsonTools {
     private val version = "1.1.1"
 
-    val tools   = "com.evolution" %% "play-json-tools"   % version
+    val tools = "com.evolution" %% "play-json-tools" % version
   }
 
   object Circe {
-    private val version       = "0.14.9"
+    private val version = "0.14.9"
     private val versionExtras = "0.14.1"
 
-    val core             = "io.circe" %% "circe-core"           % version
-    val generic          = "io.circe" %% "circe-generic"        % version
-    val parser           = "io.circe" %% "circe-parser"         % version
+    val core = "io.circe" %% "circe-core" % version
+    val generic = "io.circe" %% "circe-generic" % version
+    val parser = "io.circe" %% "circe-parser" % version
     val `generic-extras` = "io.circe" %% "circe-generic-extras" % versionExtras
 
     val all: Seq[ModuleID] = Seq(core, generic, parser, `generic-extras`)
   }
 
   object Pureconfig {
     private val version = "0.17.3"
-    val pureconfig = "com.github.pureconfig" %% "pureconfig"      % version
-    val cats       = "com.github.pureconfig" %% "pureconfig-cats" % version
+    val pureconfig = "com.github.pureconfig" %% "pureconfig" % version
+    val cats = "com.github.pureconfig" %% "pureconfig-cats" % version
   }
 }

project/plugins.sbt

@@ -1,11 +1,6 @@
 addSbtPlugin("org.scoverage" % "sbt-scoverage" % "2.2.1")
-
 addSbtPlugin("org.scoverage" % "sbt-coveralls" % "1.3.1")
-
 addSbtPlugin("com.github.sbt" % "sbt-release" % "1.1.0")
-
 addSbtPlugin("com.evolution" % "sbt-scalac-opts-plugin" % "0.0.9")
-
 addSbtPlugin("com.evolution" % "sbt-artifactory-plugin" % "0.0.2")
-
-addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.5.5")
+addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.5.5")

stracer-circe/src/main/scala/com/evolutiongaming/stracer/TraceJson.scala

@@ -1,16 +1,16 @@
 package com.evolutiongaming.stracer
 
-import io.circe.Decoder.Result
-import io.circe.{Codec, DecodingFailure, HCursor, Json}
-import io.circe.generic.semiauto._
 import cats.syntax.either._
 import com.evolutiongaming.stracer.hex.{FromHex, ToHex}
+import io.circe.Decoder.Result
+import io.circe.generic.semiauto._
+import io.circe.{Codec, DecodingFailure, HCursor, Json}
 
 object TraceJson {
 
   implicit val samplingCodec: Codec[Sampling] = new Codec[Sampling] {
     def name(a: Sampling): String = a.toString.toLowerCase
-    val elements                  = Sampling.Values.map(a => (name(a), a)).toMap
+    val elements = Sampling.Values.map(a => (name(a), a)).toMap
 
     override def apply(a: Sampling): Json = Json.fromString(name(a))
 
@@ -23,13 +23,17 @@ object TraceJson {
       } yield sampling
   }
 
-  def hexCodec[A](implicit toHex: ToHex[A], fromHex: FromHex[A]): Codec[A] = new Codec[A] {
-    override def apply(a:  A): Json = Json.fromString(toHex(a))
+  def hexCodec[A](
+    implicit
+    toHex: ToHex[A],
+    fromHex: FromHex[A],
+  ): Codec[A] = new Codec[A] {
+    override def apply(a: A): Json = Json.fromString(toHex(a))
     override def apply(c: HCursor): Result[A] =
       for {
-        hex   <- c.as[String]
-        value <- fromHex(hex).leftMap(
-          error => DecodingFailure(s"Value $hex is not a proper hex. Got error $error while decoding.", List.empty)
+        hex <- c.as[String]
+        value <- fromHex(hex).leftMap(error =>
+          DecodingFailure(s"Value $hex is not a proper hex. Got error $error while decoding.", List.empty),
         )
       } yield value
   }

stracer-circe/src/test/scala/com/evolutiongaming/stracer/TraceJsonSpec.scala

@@ -1,37 +1,38 @@
 package com.evolutiongaming.stracer
 
 import cats.syntax.all._
-import java.time.Instant
 import com.evolutiongaming.stracer.TraceJson._
 import io.circe.Decoder
 import io.circe.parser._
-
-import scala.io.Source
 import io.circe.syntax._
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
+import java.time.Instant
+import scala.io.Source
+
 class TraceJsonSpec extends AnyFunSuite with Matchers {
 
   val trace: Trace = {
 
-    val timestamp      = Instant.ofEpochMilli(1551824013554L)
-    val traceId        = TraceId(timestamp, randomInt = 12345, randomLong = 123456789L)
-    val spanId         = SpanId(1551818273913L)
+    val timestamp = Instant.ofEpochMilli(1551824013554L)
+    val traceId = TraceId(timestamp, randomInt = 12345, randomLong = 123456789L)
+    val spanId = SpanId(1551818273913L)
 
     Trace(
       traceId = traceId,
       spanId = spanId,
       parentId = none,
       timestamp = timestamp.some,
-      sampling = Sampling.Accept.some
+      sampling = Sampling.Accept.some,
     )
   }
 
   test("toJson & fromJson") {
 
     val resourceStream = getClass.getResourceAsStream("trace.json")
-    val expectedJson   = parse(Source.fromInputStream(resourceStream).mkString).getOrElse(sys.error("No file found."))
+    val expectedJson =
+      parse(Source.fromInputStream(resourceStream).mkString).getOrElse(sys.error("No file found."))
 
     val json = trace.asJson
     json shouldEqual expectedJson

stracer-kafka/src/main/scala/com/evolutiongaming/stracer/ReportSpan.scala

@@ -21,7 +21,7 @@ object ReportSpan {
     localEndpoint: Endpoint,
     tags: Tags,
     reportSpan: ReportSpanRecord[F],
-    kind: Kind
+    kind: Kind,
   ): ReportSpan[F] = new ReportSpan[F] {
 
     def apply(span: Span) = {
@@ -43,7 +43,7 @@ object ReportSpan {
         annotations = List.empty,
         tags = tags1,
         debug = None,
-        shared = span.shared
+        shared = span.shared,
       )
 
       reportSpan(record)

stracer-kafka/src/main/scala/com/evolutiongaming/stracer/ReportSpanRecord.scala

@@ -30,14 +30,14 @@ object ReportSpanRecord {
   def of[F[_]: Async: LogOf: FromTry](
     config: Config,
     enabled: F[Boolean],
-    producerOf: ProducerOf[F]
+    producerOf: ProducerOf[F],
   ): Resource[F, ReportSpanRecord[F]] = {
 
     val reportSpan = for {
-      _              <- config.getOpt[Boolean]("enabled").filter(identity)
+      _ <- config.getOpt[Boolean]("enabled").filter(identity)
       producerConfig <- config.getOpt[Config]("kafka.producer").map(ProducerConfig(_))
     } yield {
-      val topic            = config.getOpt[String]("topic") getOrElse "jaeger"
+      val topic = config.getOpt[String]("topic") getOrElse "jaeger"
       implicit val toBytes = ToBytesOf(SpanBytesEncoder.THRIFT)
       of[F](topic, producerConfig, enabled, producerOf)
     }
@@ -49,10 +49,9 @@ object ReportSpanRecord {
     topic: Topic,
     producerConfig: ProducerConfig,
     enabled: F[Boolean],
-    producerOf: ProducerOf[F]
-  )(
-    implicit
-    toBytes: ToBytes[F, Nel[SpanRecord]]
+    producerOf: ProducerOf[F],
+  )(implicit
+    toBytes: ToBytes[F, Nel[SpanRecord]],
   ): Resource[F, ReportSpanRecord[F]] = {
 
     sealed trait State
@@ -94,7 +93,7 @@ object ReportSpanRecord {
 
             case None if enabled =>
               val state = for {
-                _        <- log.info("enable")
+                _ <- log.info("enable")
                 producer <- producer(log)
               } yield {
                 State.running(producer.some)
@@ -120,8 +119,8 @@ object ReportSpanRecord {
             case _: State.Running =>
               for {
                 enabled <- enabled
-                _       <- Sync[F].uncancelable { _ => update(stateRef, enabled, log) }
-                _       <- Temporal[F].sleep(10.seconds)
+                _ <- Sync[F].uncancelable { _ => update(stateRef, enabled, log) }
+                _ <- Temporal[F].sleep(10.seconds)
               } yield {
                 ().asLeft[Unit]
               }
@@ -130,12 +129,12 @@ object ReportSpanRecord {
       }
 
     val resource = for {
-      log      <- LogOf[F].apply(getClass)
+      log <- LogOf[F].apply(getClass)
       stateRef <- SerialRef[F].of(State.running(none))
       release = stateRef.update {
         case State.Running(Some((_, release))) => release.as(State.stopped)
-        case State.Running(None)               => State.stopped.pure[F]
-        case State.Stopped                     => State.stopped.pure[F]
+        case State.Running(None) => State.stopped.pure[F]
+        case State.Stopped => State.stopped.pure[F]
       }
       fiber <- background(stateRef, log)
         .guarantee(release)
@@ -155,7 +154,7 @@ object ReportSpanRecord {
       } yield {
         state match {
           case State.Running(producer) => producer.map { case (producer, _) => producer }
-          case State.Stopped           => none[Producer[F]]
+          case State.Stopped => none[Producer[F]]
         }
       }
 
@@ -166,15 +165,19 @@ object ReportSpanRecord {
     Resource(resource)
   }
 
-  def apply[F[_]: Concurrent: FromTry](topic: Topic, producer: F[Option[Producer[F]]], log: Log[F])(
-    implicit
-    toBytes: ToBytes[F, Nel[SpanRecord]]
+  def apply[F[_]: Concurrent: FromTry](
+    topic: Topic,
+    producer: F[Option[Producer[F]]],
+    log: Log[F],
+  )(implicit
+    toBytes: ToBytes[F, Nel[SpanRecord]],
   ): ReportSpanRecord[F] = new ReportSpanRecord[F] {
 
     def apply(span: SpanRecord): F[Unit] = {
 
       def send(producer: Producer[F]) = {
-        val record = ProducerRecord[String, Nel[SpanRecord]](topic = topic, key = span.traceId.hex, value = Nel.of(span))
+        val record =
+          ProducerRecord[String, Nel[SpanRecord]](topic = topic, key = span.traceId.hex, value = Nel.of(span))
         producer
           .send(record)
           .void
@@ -187,7 +190,7 @@ object ReportSpanRecord {
 
       for {
         producer <- producer
-        result   <- producer.foldMapM(send)
+        result <- producer.foldMapM(send)
       } yield result
     }
   }

stracer-kafka/src/main/scala/com/evolutiongaming/stracer/ToBytesOf.scala

@@ -3,16 +3,16 @@ package com.evolutiongaming.stracer
 import cats.data.{NonEmptyList => Nel}
 import cats.effect.Sync
 import com.evolutiongaming.skafka.{ToBytes, Topic}
-import zipkin2.codec.SpanBytesEncoder
-
 import com.evolutiongaming.stracer.compat.CollectionConverters._
+import zipkin2.codec.SpanBytesEncoder
 
 object ToBytesOf {
 
-  def apply[F[_]: Sync](encode: SpanBytesEncoder): ToBytes[F, Nel[SpanRecord]] = { (spans: Nel[SpanRecord], _: Topic) =>
-    {
-      val spansJ = spans.toList.map(_.toJava).asJava
-      Sync[F].delay { encode.encodeList(spansJ) }
-    }
+  def apply[F[_]: Sync](encode: SpanBytesEncoder): ToBytes[F, Nel[SpanRecord]] = {
+    (spans: Nel[SpanRecord], _: Topic) =>
+      {
+        val spansJ = spans.toList.map(_.toJava).asJava
+        Sync[F].delay { encode.encodeList(spansJ) }
+      }
   }
 }

stracer-kafka/src/test/scala/com/evolutiongaming/stracer/ReportSpanSpec.scala

@@ -1,13 +1,13 @@
 package com.evolutiongaming.stracer
 
 import cats.syntax.all._
-import java.time.Instant
 import com.evolutiongaming.stracer.implicits._
-
-import scala.concurrent.duration._
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
+import java.time.Instant
+import scala.concurrent.duration._
+
 class ReportSpanSpec extends AnyFunSuite with Matchers {
 
   import ReportSpanSpec._
@@ -39,7 +39,7 @@ class ReportSpanSpec extends AnyFunSuite with Matchers {
       "name",
       timestamp,
       duration = duration.some,
-      tags = ("name2" -> "value") & ("name3" -> "value3")
+      tags = ("name2" -> "value") & ("name3" -> "value3"),
     )
 
     val reportSpan = ReportSpan[StateT](localEndpoint, tags, reportSpanRecord, Kind.producer)
@@ -58,7 +58,7 @@ class ReportSpanSpec extends AnyFunSuite with Matchers {
       annotations = List.empty,
       tags = Map(("name1", "value1"), ("name2", "value"), ("name3", "value3")),
       debug = None,
-      shared = None
+      shared = None,
     )
     state shouldEqual State(List(record))
   }