Merge series/0.23 into main

.github/workflows/ci.yml

@@ -9,9 +9,9 @@ name: Continuous Integration
 
 on:
   pull_request:
-    branches: ['**']
+    branches: ['**', '!update/**']
   push:
-    branches: ['**']
+    branches: ['**', '!update/**']
     tags: [v*]
 
 env:
@@ -87,6 +87,10 @@ jobs:
       - name: Check Java formatting
         run: sbt '++${{ matrix.scala }}' '${{ matrix.ci }}' javafmtCheckAll
 
+      - name: Check scalafix lints
+        if: matrix.java == 'temurin@8' && !startsWith(matrix.scala, '3.')
+        run: sbt '++${{ matrix.scala }}' 'scalafixAll --check'
+
       - name: Check unused compile dependencies
         if: matrix.java == 'temurin@8'
         run: sbt '++${{ matrix.scala }}' unusedCompileDependenciesTest

.scalafix.blaze.conf

@@ -0,0 +1,7 @@
+rules = [
+  RedundantSyntax
+]
+
+triggered.rules = [
+  RedundantSyntax
+]

.scalafix.conf

@@ -0,0 +1,15 @@
+rules = [
+  Http4sFs2Linters
+  Http4sGeneralLinters
+  Http4sUseLiteralsSyntax
+  LeakingImplicitClassVal
+  ExplicitResultTypes
+  OrganizeImports
+]
+
+triggered.rules = [
+  Http4sFs2Linters
+  Http4sGeneralLinters
+  Http4sUseLiteralsSyntax
+  LeakingImplicitClassVal
+]

.scalafix.test.conf

@@ -0,0 +1,12 @@
+rules = [
+  Http4sGeneralLinters
+  Http4sUseLiteralsSyntax
+  LeakingImplicitClassVal
+  OrganizeImports
+]
+
+triggered.rules = [
+  Http4sGeneralLinters
+  Http4sUseLiteralsSyntax
+  LeakingImplicitClassVal
+]

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.5.2
+version = 3.5.8
 
 style = default
 

blaze-server/src/test/scala/org/http4s/blaze/server/Http1ServerStageSpec.scala

@@ -517,7 +517,7 @@ class Http1ServerStageSpec extends CatsEffectSuite {
     .orNotFound
 
   fixture.test("Http1ServerStage: routes should Handle trailing headers") { tw =>
-    (runRequest(tw, Seq(req("foo")), routes2).result).map { buff =>
+    runRequest(tw, Seq(req("foo")), routes2).result.map { buff =>
       val results = dropDate(ResponseParser.parseBuffer(buff))
       assertEquals(results._1, Ok)
       assertEquals(results._3, "Foo: Bar")

build.sbt

@@ -22,17 +22,20 @@ ThisBuild / developers ++= List(
     "bryce-anderson",
     "Bryce L. Anderson",
     "[email protected]",
-    url("https://github.com/bryce-anderson")),
+    url("https://github.com/bryce-anderson")
+  ),
   Developer(
     "rossabaker",
     "Ross A. Baker",
     "[email protected]",
-    url("https://github.com/rossabaker")),
+    url("https://github.com/rossabaker")
+  ),
   Developer(
     "ChristopherDavenport",
     "Christopher Davenport",
     "[email protected]",
-    url("https://github.com/ChristopherDavenport"))
+    url("https://github.com/ChristopherDavenport")
+  )
 )
 ThisBuild / startYear := Some(2014)
 
@@ -50,7 +53,8 @@ lazy val commonSettings = Seq(
     }
   },
   run / fork := true,
-  scalafmtConfig := file(".scalafmt.blaze.conf")
+  scalafmtConfig := file(".scalafmt.blaze.conf"),
+  scalafixConfig := Some(file(".scalafix.blaze.conf"))
 )
 
 // currently only publishing tags
@@ -60,7 +64,8 @@ ThisBuild / githubWorkflowPublishTargetBranches :=
 ThisBuild / githubWorkflowBuild ++= Seq(
   WorkflowStep.Sbt(
     List("${{ matrix.ci }}", "javafmtCheckAll"),
-    name = Some("Check Java formatting"))
+    name = Some("Check Java formatting")
+  )
 )
 
 lazy val blaze = project
@@ -93,7 +98,8 @@ lazy val core = Project("blaze-core", file("core"))
     mimaBinaryIssueFilters ++= Seq(
       // private constructor for which there are no sensible defaults
       ProblemFilters.exclude[DirectMissingMethodProblem](
-        "org.http4s.blaze.channel.nio1.NIO1SocketServerGroup.this")
+        "org.http4s.blaze.channel.nio1.NIO1SocketServerGroup.this"
+      )
     )
   )
   .dependsOn(testkit % Test)
@@ -107,14 +113,16 @@ lazy val http = Project("blaze-http", file("http"))
     // Test Dependencies
     libraryDependencies += asyncHttpClient % Test,
     mimaBinaryIssueFilters ++= Seq(
+      ProblemFilters
+        .exclude[MissingClassProblem]("org.http4s.blaze.http.http2.PingManager$PingState"),
+      ProblemFilters
+        .exclude[MissingClassProblem]("org.http4s.blaze.http.http2.PingManager$PingState$"),
       ProblemFilters.exclude[MissingClassProblem](
-        "org.http4s.blaze.http.http2.PingManager$PingState"),
-      ProblemFilters.exclude[MissingClassProblem](
-        "org.http4s.blaze.http.http2.PingManager$PingState$"),
-      ProblemFilters.exclude[MissingClassProblem](
-        "org.http4s.blaze.http.http2.client.ALPNClientSelector$ClientProvider"),
+        "org.http4s.blaze.http.http2.client.ALPNClientSelector$ClientProvider"
+      ),
       ProblemFilters.exclude[MissingClassProblem](
-        "org.http4s.blaze.http.http2.server.ALPNServerSelector$ServerProvider")
+        "org.http4s.blaze.http.http2.server.ALPNServerSelector$ServerProvider"
+      )
     )
   )
   .dependsOn(testkit % Test, core % "test->test;compile->compile")
@@ -159,7 +167,8 @@ lazy val blazeCore = project
             .exclude[DirectMissingMethodProblem]("org.http4s.blazecore.util.IdentityWriter.ec")
         )
       else Seq.empty
-    }
+    },
+    Test / scalafixConfig := Some(file(".scalafix.test.conf"))
   )
   .dependsOn(http)
 
@@ -221,7 +230,8 @@ lazy val blazeServer = project
           )
         )
       else Seq.empty,
-    }
+    },
+    Test / scalafixConfig := Some(file(".scalafix.test.conf"))
   )
   .dependsOn(blazeCore % "compile;test->test")
 
@@ -317,7 +327,8 @@ lazy val blazeClient = project
           )
         )
       else Seq.empty
-    }
+    },
+    Test / scalafixConfig := Some(file(".scalafix.test.conf"))
   )
   .dependsOn(blazeCore % "compile;test->test")
 
@@ -330,7 +341,8 @@ lazy val examples = Project("blaze-examples", file("examples"))
       "org.http4s" %% "http4s-dsl" % http4sVersion,
       "org.http4s" %% "http4s-circe" % http4sVersion,
       "io.circe" %% "circe-generic" % "0.14.2"
-    )
+    ),
+    Test / scalafixConfig := Some(file(".scalafix.test.conf"))
   )
   .dependsOn(blazeServer, blazeClient)
 
@@ -339,4 +351,5 @@ lazy val examples = Project("blaze-examples", file("examples"))
 // use it in the local development process
 addCommandAlias(
   "validate",
-  ";scalafmtCheckAll ;scalafmtSbtCheck ;javafmtCheckAll ;+test:compile ;test ;unusedCompileDependenciesTest ;mimaReportBinaryIssues")
+  ";scalafmtCheckAll ;scalafmtSbtCheck ;javafmtCheckAll ;+test:compile ;test ;unusedCompileDependenciesTest ;mimaReportBinaryIssues"
+)

core/src/main/scala/org/http4s/blaze/channel/ServerChannel.scala

@@ -85,8 +85,9 @@ abstract class ServerChannel extends Closeable { self =>
     * @return
     *   true if the hook was successfully registered, false otherwise.
     */
-  final def addShutdownHook(f: () => Unit)(implicit
-      ec: ExecutionContext = Execution.directec): Boolean =
+  final def addShutdownHook(
+      f: () => Unit
+  )(implicit ec: ExecutionContext = Execution.directec): Boolean =
     shutdownHooks.synchronized {
       if (state != Open) false
       else {

core/src/main/scala/org/http4s/blaze/channel/nio1/NIO1ClientChannel.scala

@@ -25,8 +25,8 @@ import java.util.concurrent.atomic.AtomicBoolean
 
 private[blaze] final class NIO1ClientChannel(
     private[this] val underlying: SocketChannel,
-    private[this] val onClose: () => Unit)
-    extends NIO1Channel {
+    private[this] val onClose: () => Unit
+) extends NIO1Channel {
 
   private[this] val closed = new AtomicBoolean(false)
 

core/src/main/scala/org/http4s/blaze/channel/nio1/NIO1HeadStage.scala

@@ -72,7 +72,8 @@ private[nio1] object NIO1HeadStage {
   private def performWrite(
       ch: NIO1ClientChannel,
       scratch: ByteBuffer,
-      buffers: Array[ByteBuffer]): WriteResult =
+      buffers: Array[ByteBuffer]
+  ): WriteResult =
     try
       if (BufferTools.areDirectOrEmpty(buffers)) {
         ch.write(buffers)
@@ -198,7 +199,7 @@ private[nio1] final class NIO1HeadStage(
 
   // /  channel reading bits //////////////////////////////////////////////
 
-  final override def readRequest(size: Int): Future[ByteBuffer] = {
+  override final def readRequest(size: Int): Future[ByteBuffer] = {
     logger.trace(s"NIOHeadStage received a read request of size $size")
     val p = Promise[ByteBuffer]()
 
@@ -238,10 +239,10 @@ private[nio1] final class NIO1HeadStage(
 
   // / channel write bits /////////////////////////////////////////////////
 
-  final override def writeRequest(data: ByteBuffer): Future[Unit] =
+  override final def writeRequest(data: ByteBuffer): Future[Unit] =
     writeRequest(data :: Nil)
 
-  final override def writeRequest(data: collection.Seq[ByteBuffer]): Future[Unit] = {
+  override final def writeRequest(data: collection.Seq[ByteBuffer]): Future[Unit] = {
     logger.trace(s"NIO1HeadStage Write Request: $data")
     val p = Promise[Unit]()
     selectorLoop.executeTask(new selectorLoop.LoopRunnable {
@@ -289,9 +290,9 @@ private[nio1] final class NIO1HeadStage(
 
   // /////////////////////////////// Channel Ops ////////////////////////////////////////
 
-  final override def close(cause: Option[Throwable]): Unit = doClosePipeline(cause)
+  override final def close(cause: Option[Throwable]): Unit = doClosePipeline(cause)
 
-  final override protected def doClosePipeline(cause: Option[Throwable]): Unit = {
+  override protected final def doClosePipeline(cause: Option[Throwable]): Unit = {
     // intended to be called from within the SelectorLoop but if
     // it's closed it will be performed in the current thread
     def doClose(t: Throwable): Unit = {
@@ -324,7 +325,8 @@ private[nio1] final class NIO1HeadStage(
       selectorLoop.executeTask(new Runnable {
         def run(): Unit = {
           logger.trace(
-            s"closeWithError($cause); readPromise: $readPromise, writePromise: $writePromise")
+            s"closeWithError($cause); readPromise: $readPromise, writePromise: $writePromise"
+          )
           val c = cause match {
             case Some(ex) =>
               logger.error(cause.get)("Abnormal NIO1HeadStage termination")

core/src/main/scala/org/http4s/blaze/channel/nio1/NIO1SocketServerGroup.scala

@@ -122,8 +122,8 @@ private final class NIO1SocketServerGroup private (
     acceptorPool: SelectorLoopPool,
     workerPool: SelectorLoopPool,
     channelOptions: ChannelOptions,
-    maxConnections: Int)
-    extends ServerChannelGroup {
+    maxConnections: Int
+) extends ServerChannelGroup {
   private[this] val logger = getLogger
   // Also acts as our intrinsic lock.
   private[this] val listeningSet = new mutable.HashSet[ServerChannelImpl]()
@@ -140,8 +140,8 @@ private final class NIO1SocketServerGroup private (
   private[this] class SocketAcceptor(
       key: SelectionKey,
       ch: ServerChannelImpl,
-      service: SocketPipelineBuilder)
-      extends Selectable {
+      service: SocketPipelineBuilder
+  ) extends Selectable {
     // Save it since once the channel is closed, we're in trouble.
     private[this] val closed = new AtomicBoolean(false)
 
@@ -192,8 +192,8 @@ private final class NIO1SocketServerGroup private (
   // minimize race conditions.
   private[this] final class ServerChannelImpl(
       val selectableChannel: ServerSocketChannel,
-      selectorLoop: SelectorLoop)
-      extends ServerChannel
+      selectorLoop: SelectorLoop
+  ) extends ServerChannel
       with NIO1Channel {
     @volatile
     private[this] var closed = false

core/src/main/scala/org/http4s/blaze/channel/nio1/SelectorLoop.scala

@@ -264,7 +264,7 @@ final class SelectorLoop(
       */
     def run(scratch: ByteBuffer): Unit
 
-    final override def run(): Unit = {
+    override final def run(): Unit = {
       val currentThread = Thread.currentThread
       if (currentThread == thread) run(scratch)
       else {

core/src/main/scala/org/http4s/blaze/channel/nio2/ClientChannelFactory.scala

@@ -44,19 +44,22 @@ final class ClientChannelFactory(
     group: Option[AsynchronousChannelGroup] = None,
     channelOptions: ChannelOptions = ChannelOptions.DefaultOptions,
     scheduler: TickWheelExecutor = Execution.scheduler,
-    connectTimeout: Duration = Duration.Inf) {
+    connectTimeout: Duration = Duration.Inf
+) {
   private[this] val logger = getLogger
 
   // for binary compatibility with <=0.14.6
   def this(
       bufferSize: Int,
       group: Option[AsynchronousChannelGroup],
-      channelOptions: ChannelOptions) =
+      channelOptions: ChannelOptions
+  ) =
     this(bufferSize, group, channelOptions, Execution.scheduler, Duration.Inf)
 
   def connect(
       remoteAddress: SocketAddress,
-      bufferSize: Int = bufferSize): Future[HeadStage[ByteBuffer]] = {
+      bufferSize: Int = bufferSize
+  ): Future[HeadStage[ByteBuffer]] = {
     val p = Promise[HeadStage[ByteBuffer]]()
 
     try {
@@ -65,7 +68,8 @@ final class ClientChannelFactory(
       val onTimeout = new Runnable {
         override def run(): Unit = {
           val exception = new SocketTimeoutException(
-            s"An attempt to establish connection with $remoteAddress timed out after $connectTimeout.")
+            s"An attempt to establish connection with $remoteAddress timed out after $connectTimeout."
+          )
           val finishedWithTimeout = p.tryFailure(exception)
           if (finishedWithTimeout)
             try ch.close()

core/src/main/scala/org/http4s/blaze/pipeline/PipelineBuilder.scala

@@ -56,7 +56,8 @@ object LeafBuilder {
   */
 final class TrunkBuilder[I1, O] private[pipeline] (
     protected val head: MidStage[I1, _],
-    protected val tail: MidStage[_, O]) {
+    protected val tail: MidStage[_, O]
+) {
   def append[N](stage: MidStage[O, N]): TrunkBuilder[I1, N] = {
     if (stage._prevStage != null) sys.error(s"Stage $stage must be fresh")
     if (stage.isInstanceOf[HeadStage[_]])

core/src/main/scala/org/http4s/blaze/pipeline/Stages.scala

@@ -45,7 +45,7 @@ import scala.util.control.NonFatal
  */
 
 sealed trait Stage {
-  final protected val logger = getLogger(this.getClass)
+  protected final val logger = getLogger(this.getClass)
 
   def name: String
 

core/src/main/scala/org/http4s/blaze/pipeline/stages/TimeoutStageBase.scala

@@ -71,13 +71,13 @@ abstract class TimeoutStageBase[T](timeout: Duration, exec: TickWheelExecutor)
     super.stageShutdown()
   }
 
-  final protected def resetTimeout(): Unit =
+  protected final def resetTimeout(): Unit =
     setAndCancel(exec.schedule(killswitch, timeout))
 
-  final protected def cancelTimeout(): Unit =
+  protected final def cancelTimeout(): Unit =
     setAndCancel(Cancelable.NoopCancel)
 
-  final protected def startTimeout(): Unit = resetTimeout()
+  protected final def startTimeout(): Unit = resetTimeout()
 }
 
 private object TimeoutStageBase {