Update scalafmt-core to 3.0.8

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.0.7
+version = 3.0.8
 
 style = default
 

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

@@ -194,7 +194,7 @@ private[nio1] final class NIO1HeadStage(
     }
   }
 
-  ///  channel reading bits //////////////////////////////////////////////
+  // /  channel reading bits //////////////////////////////////////////////
 
   final override def readRequest(size: Int): Future[ByteBuffer] = {
     logger.trace(s"NIOHeadStage received a read request of size $size")
@@ -234,7 +234,7 @@ private[nio1] final class NIO1HeadStage(
     p.future
   }
 
-  /// channel write bits /////////////////////////////////////////////////
+  // / channel write bits /////////////////////////////////////////////////
 
   final override def writeRequest(data: ByteBuffer): Future[Unit] =
     writeRequest(data :: Nil)
@@ -285,7 +285,7 @@ private[nio1] final class NIO1HeadStage(
     p.future
   }
 
-  ///////////////////////////////// Channel Ops ////////////////////////////////////////
+  // /////////////////////////////// Channel Ops ////////////////////////////////////////
 
   final override def close(cause: Option[Throwable]): Unit = doClosePipeline(cause)
 

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

@@ -202,7 +202,7 @@ sealed trait Tail[I] extends Stage {
       p.future
     } else f
 
-  ///////////////////////////////////////////////////////////////////
+  // /////////////////////////////////////////////////////////////////
   /** Schedules a timeout and sets it to race against the provided future
     * @param p
     *   Promise[T] to be completed by whichever comes first: the timeout or resolution of the

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

@@ -30,7 +30,7 @@ trait ByteToObjectStage[O] extends MidStage[ByteBuffer, O] {
 
   private var _decodeBuffer: ByteBuffer = null
 
-  /////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////
 
   /** Encode objects to buffers
     * @param in
@@ -55,7 +55,7 @@ trait ByteToObjectStage[O] extends MidStage[ByteBuffer, O] {
 
   val maxBufferSize: Int
 
-  /////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////
 
   override def writeRequest(data: collection.Seq[O]): Future[Unit] =
     try channelWrite(data.flatMap(messageToBuffer))

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

@@ -25,7 +25,7 @@ import scala.concurrent.duration.Duration
 /** Shut down the pipeline after a period of inactivity */
 class QuietTimeoutStage[T](timeout: Duration, exec: TickWheelExecutor = scheduler)
     extends TimeoutStageBase[T](timeout, exec) {
-  ////////////////////////////////////////////////////////////////////////////////
+  // //////////////////////////////////////////////////////////////////////////////
 
   override protected def stageStartup(): Unit = {
     super.stageStartup()

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

@@ -77,20 +77,20 @@ final class SSLStage(engine: SSLEngine, maxWrite: Int = 1024 * 1024)
       engine.closeOutbound()
     } catch {
       case e: SSLException =>
-        //Ignore cleanup errors. Example: With JDK SSLContextImpl, if the connection is closed before even handshake
-        //began(like port scanning), an SSLException might be thrown.
+        // Ignore cleanup errors. Example: With JDK SSLContextImpl, if the connection is closed before even handshake
+        // began(like port scanning), an SSLException might be thrown.
         logger.debug(e)("Error while closing SSL Engine")
     }
 
   private[this] val maxNetSize = engine.getSession.getPacketBufferSize
   private[this] val maxBuffer = math.max(maxNetSize, engine.getSession.getApplicationBufferSize)
 
-  ///////////// State maintained by the SSLStage //////////////////////
+  // /////////// State maintained by the SSLStage //////////////////////
   private[this] val handshakeQueue = new ListBuffer[DelayedOp]
   private[this] var readLeftover: ByteBuffer = null
-  /////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////
 
-  /////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////
 
   override def writeRequest(data: collection.Seq[ByteBuffer]): Future[Unit] =
     writeArray(data.toArray)
@@ -104,7 +104,7 @@ final class SSLStage(engine: SSLEngine, maxWrite: Int = 1024 * 1024)
     p.future
   }
 
-  /////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////
 
   private[this] def writeArray(data: Array[ByteBuffer]): Future[Unit] = {
     val p = Promise[Unit]()

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

@@ -34,7 +34,7 @@ abstract class TimeoutStageBase[T](timeout: Duration, exec: TickWheelExecutor)
 
   override def name: String = s"${this.getClass.getName} Stage: $timeout"
 
-  /////////// Private impl bits //////////////////////////////////////////
+  // ///////// Private impl bits //////////////////////////////////////////
 
   private val lastTimeout =
     new AtomicReference[Cancelable](Cancelable.NoopCancel)
@@ -56,15 +56,15 @@ abstract class TimeoutStageBase[T](timeout: Duration, exec: TickWheelExecutor)
     } else prev.cancel()
   }
 
-  /////////// Pass through implementations ////////////////////////////////
+  // ///////// Pass through implementations ////////////////////////////////
 
   override def readRequest(size: Int): Future[T] = channelRead(size)
 
   override def writeRequest(data: T): Future[Unit] = channelWrite(data)
 
   override def writeRequest(data: collection.Seq[T]): Future[Unit] = channelWrite(data)
 
-  /////////// Protected impl bits //////////////////////////////////////////
+  // ///////// Protected impl bits //////////////////////////////////////////
 
   override protected def stageShutdown(): Unit = {
     setAndCancel(closedTag)

core/src/main/scala/org/http4s/blaze/util/TaskQueue.scala

@@ -105,7 +105,7 @@ private[blaze] final class TaskQueue {
           // If we are not the last cell, we will spin until the cons resolves and continue
           if (!queueTail.compareAndSet(node, null))
             go(spin(node))
-          //else () // Finished the last node. All done.
+          // else () // Finished the last node. All done.
         } else go(next)
       }
 

core/src/main/scala/org/http4s/blaze/util/TickWheelExecutor.scala

@@ -63,7 +63,7 @@ class TickWheelExecutor(wheelSize: Int = DefaultWheelSize, val tick: Duration =
   private val clockFace: Array[Bucket] =
     (0 until wheelSize).map(_ => new Bucket()).toArray
 
-  /////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////
   // new Thread that actually runs the execution.
 
   private val thread = new Thread(s"blaze-tick-wheel-executor") {
@@ -74,7 +74,7 @@ class TickWheelExecutor(wheelSize: Int = DefaultWheelSize, val tick: Duration =
   thread.setDaemon(true)
   thread.start()
 
-  /////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////
 
   def shutdown(): Unit =
     alive = false

examples/src/main/scala/org/http4s/blaze/examples/ExampleKeystore.scala

@@ -48,7 +48,7 @@ object ExampleKeystore {
      */
 
     val ksStream =
-      getClass.getResourceAsStream("/clientauth/server.jks") //BogusKeystore.asInputStream()
+      getClass.getResourceAsStream("/clientauth/server.jks") // BogusKeystore.asInputStream()
     assert(ksStream != null)
 
     val ks = KeyStore.getInstance("JKS")

http/src/main/scala/org/http4s/blaze/http/http2/FrameDecoder.scala

@@ -113,9 +113,9 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
     Continue
   }
 
-  //////////////// Decoding algorithms ///////////////////////////////////////////////////////////
+  // ////////////// Decoding algorithms ///////////////////////////////////////////////////////////
 
-  //////////// DATA ///////////////
+  // ////////// DATA ///////////////
   // https://tools.ietf.org/html/rfc7540#section-6.1
   private[this] def decodeDataFrame(buffer: ByteBuffer, streamId: Int, flags: Byte): Result =
     if (streamId == 0)
@@ -143,7 +143,7 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
         listener.onDataFrame(streamId, Flags.END_STREAM(flags), buffer.slice(), flowBytes)
     }
 
-  //////////// HEADERS ///////////////
+  // ////////// HEADERS ///////////////
   private[this] def decodeHeaderFrame(buffer: ByteBuffer, streamId: Int, flags: Byte): Result =
     if (streamId == 0)
       Error(PROTOCOL_ERROR.goaway("Headers frame with stream id 0x0"))
@@ -174,7 +174,7 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
         }
     }
 
-  //////////// PRIORITY ///////////////
+  // ////////// PRIORITY ///////////////
   private[this] def decodePriorityFrame(buffer: ByteBuffer, streamId: Int): Result =
     if (streamId == 0)
       Error(PROTOCOL_ERROR.goaway("Priority frame with stream id 0x0"))
@@ -189,7 +189,7 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
         listener.onPriorityFrame(streamId, priority)
     }
 
-  //////////// RST_STREAM ///////////////
+  // ////////// RST_STREAM ///////////////
   private[this] def decodeRstStreamFrame(buffer: ByteBuffer, streamId: Int): Result =
     if (streamId == 0)
       Error(PROTOCOL_ERROR.goaway("RST_STREAM frame with stream id 0x0"))
@@ -201,7 +201,7 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
       listener.onRstStreamFrame(streamId, code)
     }
 
-  //////////// SETTINGS ///////////////
+  // ////////// SETTINGS ///////////////
   private[this] def decodeSettingsFrame(buffer: ByteBuffer, streamId: Int, flags: Byte): Result =
     SettingsDecoder.decodeSettingsFrame(buffer, streamId, flags) match {
       case Right(SettingsFrame(settings)) =>
@@ -211,7 +211,7 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
         Error(ex)
     }
 
-  //////////// PUSH_PROMISE ///////////////
+  // ////////// PUSH_PROMISE ///////////////
   private[this] def decodePushPromiseFrame(buffer: ByteBuffer, streamId: Int, flags: Byte): Result =
     if (streamId == 0)
       Error(PROTOCOL_ERROR.goaway("PUSH_PROMISE frame with stream id 0x0"))
@@ -240,7 +240,7 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
       }
     }
 
-  //////////// PING ///////////////
+  // ////////// PING ///////////////
   private[this] def decodePingFrame(buffer: ByteBuffer, streamId: Int, flags: Byte): Result = {
     val PingSize = 8
     if (streamId != 0)
@@ -255,7 +255,7 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
     }
   }
 
-  //////////// GOAWAY ///////////////
+  // ////////// GOAWAY ///////////////
   private[this] def decodeGoAwayFrame(buffer: ByteBuffer, streamId: Int): Result =
     if (streamId != 0)
       Error(PROTOCOL_ERROR.goaway(s"GOAWAY frame with stream id ${hexStr(streamId)} != 0x0."))
@@ -268,7 +268,7 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
       listener.onGoAwayFrame(lastStream, code, data)
     }
 
-  //////////// WINDOW_UPDATE ///////////////
+  // ////////// WINDOW_UPDATE ///////////////
   private[this] def decodeWindowUpdateFrame(buffer: ByteBuffer, streamId: Int): Result =
     if (buffer.remaining != 4)
       Error(
@@ -287,7 +287,7 @@ private class FrameDecoder(localSettings: Http2Settings, listener: FrameListener
         }
     }
 
-  //////////// CONTINUATION ///////////////
+  // ////////// CONTINUATION ///////////////
   private[this] def decodeContinuationFrame(
       buffer: ByteBuffer,
       streamId: Int,

http/src/main/scala/org/http4s/blaze/http/http2/FrameSerializer.scala

@@ -274,7 +274,7 @@ private[http2] object FrameSerializer {
     buffer :: headerBuffer :: Nil
   }
 
-  //////////////////////////////////////////////////////////////////////////////////////////
+  // ////////////////////////////////////////////////////////////////////////////////////////
 
   private[this] def writePriority(p: Priority.Dependent, buffer: ByteBuffer): Unit = {
     if (p.exclusive)

http/src/main/scala/org/http4s/blaze/http/http2/HeaderAggregatingFrameListener.scala

@@ -54,7 +54,7 @@ private abstract class HeaderAggregatingFrameListener(
 
   private[this] var hInfo: PartialFrame = null
 
-  ///////////////////////////////////////////////////////////////////////////
+  // /////////////////////////////////////////////////////////////////////////
 
   /** Called on the successful receipt of a complete HEADERS block
     *
@@ -85,7 +85,7 @@ private abstract class HeaderAggregatingFrameListener(
     */
   def onCompletePushPromiseFrame(streamId: Int, promisedId: Int, headers: Headers): Result
 
-  ////////////////////////////////////////////////////////////////////////////
+  // //////////////////////////////////////////////////////////////////////////
 
   final def setMaxHeaderTableSize(maxSize: Int): Unit =
     headerDecoder.setMaxHeaderTableSize(maxSize)

http/src/main/scala/org/http4s/blaze/http/http2/SessionFlowControlImpl.scala

@@ -170,7 +170,7 @@ private class SessionFlowControlImpl(
   private[this] def sessionWindowString: String =
     s"Session: {inbound: $sessionInboundWindow, unconsumed: $sessionUnconsumedBytes, outbound: $sessionOutboundWindow}"
 
-  ////////////////////////////////////////////////////////////////////
+  // //////////////////////////////////////////////////////////////////
 
   private[this] final class StreamFlowWindowImpl(val streamId: Int) extends StreamFlowWindow {
     private[this] var _streamInboundWindow: Int =

http/src/main/scala/org/http4s/blaze/http/http2/StreamStateImpl.scala

@@ -206,7 +206,7 @@ private abstract class StreamStateImpl(session: SessionCore) extends StreamState
       }
   }
 
-  ///////////////////// Inbound messages ///////////////////////////////
+  // /////////////////// Inbound messages ///////////////////////////////
 
   final override def invokeInboundData(
       endStream: Boolean,
@@ -249,7 +249,7 @@ private abstract class StreamStateImpl(session: SessionCore) extends StreamState
       Continue
     }
 
-  //////////////////////////////////////////////////////////////////////
+  // ////////////////////////////////////////////////////////////////////
 
   final override protected def doClosePipeline(cause: Option[Throwable]): Unit =
     session.serialExecutor.execute(new Runnable { def run(): Unit = doCloseWithError(cause) })

http/src/main/scala/org/http4s/blaze/http/http2/bits.scala

@@ -49,7 +49,7 @@ private[http2] object bits {
     val CONTINUATION: Byte = 0x09
   }
 
-  //////////////////////////////////////////////////
+  // ////////////////////////////////////////////////
 
   object Flags {
     val END_STREAM: Byte = 0x1

http/src/test/scala/org/http4s/blaze/http/http2/SessionFlowControlSuite.scala

@@ -147,7 +147,7 @@ class SessionFlowControlSuite extends BlazeTestSuite {
     }
   }
 
-  ////////////////// Streams ////////////////////////////
+  // //////////////// Streams ////////////////////////////
 
   test(
     "A SessionFlowControl.StreamFlowWindow inbound window should start with the config initial flow windows") {

http/src/test/scala/org/http4s/blaze/http/parser/Benchmarks.scala

@@ -81,7 +81,7 @@ class Benchmarks extends BlazeTestSuite {
       }
 
       override def headerComplete(name: String, value: String): Boolean =
-        //println(s"Header($name, $value)")
+        // println(s"Header($name, $value)")
         super.headerComplete(name, value)
 
       //      override def submitRequestLine(methodString: String, uri: String, scheme: String, majorversion: Int, minorversion: Int): Unit = {
@@ -104,7 +104,7 @@ class Benchmarks extends BlazeTestSuite {
       assert(p.parseLine(b)) // should equal(true)
       assert(p.requestLineComplete())
 
-      p.parseheaders(b) //should equal(true)
+      p.parseheaders(b) // should equal(true)
       assert(p.headersComplete())
 
       p.parsecontent(b)

http/src/test/scala/org/http4s/blaze/http/parser/ClientParserSuite.scala

@@ -173,7 +173,7 @@ class ClientParserSuite extends BlazeTestSuite {
     val p = new TestParser
     val msg = resp + l_headersstr
 
-    //println(msg.replace("\r\n", "\\r\\n\r\n"))
+    // println(msg.replace("\r\n", "\\r\\n\r\n"))
 
     val bts = wrap(msg.getBytes(ISO_8859_1))
     assert(p.parseResponse(bts))

http/src/test/scala/org/http4s/blaze/http/parser/ServerParserSuite.scala

@@ -63,7 +63,7 @@ class ServerParserSuite extends BlazeTestSuite {
     }
 
     def headerComplete(name: String, value: String) = {
-      //println(s"Found header: '$name': '$value'")
+      // println(s"Found header: '$name': '$value'")
       h += ((name, value))
       false
     }
@@ -303,7 +303,7 @@ class ServerParserSuite extends BlazeTestSuite {
     val req = mockChunked.substring(0, mockChunked.length - 2) + "Foo\r\n\r\n"
     val b = strToBuffer(req)
 
-    //println(mockChunked)
+    // println(mockChunked)
 
     assert(p.parseLine(b))