Update scalafmt

Author: adamw

.scalafmt.conf

@@ -1,2 +1,3 @@
-version = 2.7.5
+runner.dialect = scala3
+version = 3.0.0
 maxColumn = 120

core/src/main/scala/sttp/capabilities/package.scala

@@ -3,21 +3,21 @@ package sttp
 package object capabilities {
 
   /** A capability of sending and receiving streaming bodies.
-    * @tparam S The type to use as a capability. Should be the self-type of the implementation. This is needed so that
-    *           capabilities are expressed in terms of class types, not singleton object types.
+    * @tparam S
+    *   The type to use as a capability. Should be the self-type of the implementation. This is needed so that
+    *   capabilities are expressed in terms of class types, not singleton object types.
     */
   class Streams[S] {
     type BinaryStream
     type Pipe[_, _]
   }
 
-  /** A capability of supporting the given effect type, such as [[scala.concurrent.Future]].
-    * Used only as a type parameter, without implementations.
+  /** A capability of supporting the given effect type, such as [[scala.concurrent.Future]]. Used only as a type
+    * parameter, without implementations.
     */
   trait Effect[F[_]]
 
-  /** A capability of sending websocket requests.
-    * Used only as a type parameter, without implementations.
+  /** A capability of sending websocket requests. Used only as a type parameter, without implementations.
     */
   trait WebSockets
 }

core/src/main/scala/sttp/monad/MonadError.scala

@@ -3,17 +3,15 @@ package sttp.monad
 import scala.concurrent.{ExecutionContext, Future, Promise}
 import scala.util.{Failure, Success, Try}
 
-/** A basic monad interface, allowing abstract manipulation of effectful values, represented using the type
-  * constructor `F`.
+/** A basic monad interface, allowing abstract manipulation of effectful values, represented using the type constructor
+  * `F`.
   *
-  * A computation yielding results of type `T` is represented as a value of type `F[T]`. Such values:
-  * * can be transformed using `map`
-  * * can be run in sequence using `flatMap`
-  * * errors can be handled using `handleError`
-  * * and new computations can be created using `unit`, `eval` and `suspend`
+  * A computation yielding results of type `T` is represented as a value of type `F[T]`. Such values: * can be
+  * transformed using `map` * can be run in sequence using `flatMap` * errors can be handled using `handleError` * and
+  * new computations can be created using `unit`, `eval` and `suspend`
   *
-  * To use convenient `.map`, `.flatMap` syntax, make sure an implicit instance of `MonadError` is in scope, and
-  * import: `import sttp.monad.syntax._`. This adds the appropriate extension methods.
+  * To use convenient `.map`, `.flatMap` syntax, make sure an implicit instance of `MonadError` is in scope, and import:
+  * `import sttp.monad.syntax._`. This adds the appropriate extension methods.
   */
 trait MonadError[F[_]] {
   def unit[T](t: T): F[T]

ws/src/main/scala/sttp/ws/WebSocket.scala

@@ -6,13 +6,13 @@ import sttp.monad.syntax._
 
 /** Effectful interactions with a web socket. Interactions can happen:
   *
-  * - on the frame level, by sending and receiving raw [[WebSocketFrame]]s
-  * - using the provided `receive*` methods to obtain concatenated data frames, or string/byte payloads, and the
-  *   `send*` method to send string/binary frames.
+  *   - on the frame level, by sending and receiving raw [[WebSocketFrame]] s
+  *   - using the provided `receive*` methods to obtain concatenated data frames, or string/byte payloads, and the
+  *     `send*` method to send string/binary frames.
   *
   * The `send*` and `receive*` methods may result in a failed effect, with either one of [[WebSocketException]]
-  * exceptions, or a backend-specific exception. Specifically, they will fail with [[WebSocketClosed]] if the
-  * web socket is closed.
+  * exceptions, or a backend-specific exception. Specifically, they will fail with [[WebSocketClosed]] if the web socket
+  * is closed.
   *
   * See the `either` and `eitherClose` method to lift web socket closed events to the value level.
   */
@@ -23,8 +23,8 @@ trait WebSocket[F[_]] {
     * happen.
     *
     * However, not all implementations expose the close frame, and web sockets might also get closed without the proper
-    * close frame exchange. In such cases, as well as when invoking `receive`/`send` after receiving a close frame,
-    * this effect will fail with the [[WebSocketClosed]] exception.
+    * close frame exchange. In such cases, as well as when invoking `receive`/`send` after receiving a close frame, this
+    * effect will fail with the [[WebSocketClosed]] exception.
     *
     * *Should be only called sequentially!* (from a single thread/fiber). Because web socket frames might be fragmented,
     * calling this method concurrently might result in threads/fibers receiving fragments of the same frame.
@@ -38,12 +38,13 @@ trait WebSocket[F[_]] {
   def send(f: WebSocketFrame, isContinuation: Boolean = false): F[Unit]
   def isOpen(): F[Boolean]
 
-  /** Receive a single data frame, ignoring others. The frame might be a fragment.
-    * Will fail with [[WebSocketClosed]] if the web socket is closed, or if a close frame is received.
+  /** Receive a single data frame, ignoring others. The frame might be a fragment. Will fail with [[WebSocketClosed]] if
+    * the web socket is closed, or if a close frame is received.
     *
     * *Should be only called sequentially!* (from a single thread/fiber).
     *
-    * @param pongOnPing Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
+    * @param pongOnPing
+    *   Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
     */
   def receiveDataFrame(pongOnPing: Boolean = true): F[WebSocketFrame.Data[_]] =
     receive().flatMap {
@@ -54,62 +55,66 @@ trait WebSocket[F[_]] {
       case _ => receiveDataFrame(pongOnPing)
     }
 
-  /** Receive a single text data frame, ignoring others. The frame might be a fragment. To receive whole messages,
-    * use [[receiveText]].
-    * Will fail with [[WebSocketClosed]] if the web socket is closed, or if a close frame is received.
+  /** Receive a single text data frame, ignoring others. The frame might be a fragment. To receive whole messages, use
+    * [[receiveText]]. Will fail with [[WebSocketClosed]] if the web socket is closed, or if a close frame is received.
     *
     * *Should be only called sequentially!* (from a single thread/fiber).
     *
-    * @param pongOnPing Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
+    * @param pongOnPing
+    *   Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
     */
   def receiveTextFrame(pongOnPing: Boolean = true): F[WebSocketFrame.Text] =
     receiveDataFrame(pongOnPing).flatMap {
       case t: WebSocketFrame.Text => t.unit
       case _                      => receiveTextFrame(pongOnPing)
     }
 
-  /** Receive a single binary data frame, ignoring others. The frame might be a fragment. To receive whole messages,
-    * use [[receiveBinary]].
-    * Will fail with [[WebSocketClosed]] if the web socket is closed, or if a close frame is received.
+  /** Receive a single binary data frame, ignoring others. The frame might be a fragment. To receive whole messages, use
+    * [[receiveBinary]]. Will fail with [[WebSocketClosed]] if the web socket is closed, or if a close frame is
+    * received.
     *
     * *Should be only called sequentially!* (from a single thread/fiber).
     *
-    * @param pongOnPing Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
+    * @param pongOnPing
+    *   Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
     */
   def receiveBinaryFrame(pongOnPing: Boolean = true): F[WebSocketFrame.Binary] =
     receiveDataFrame(pongOnPing).flatMap {
       case t: WebSocketFrame.Binary => t.unit
       case _                        => receiveBinaryFrame(pongOnPing)
     }
 
-  /** Receive a single text message (which might come from multiple, fragmented frames).
-    * Ignores non-text frames and returns combined results.
-    * Will fail with [[WebSocketClosed]] if the web socket is closed, or if a close frame is received.
+  /** Receive a single text message (which might come from multiple, fragmented frames). Ignores non-text frames and
+    * returns combined results. Will fail with [[WebSocketClosed]] if the web socket is closed, or if a close frame is
+    * received.
     *
     * *Should be only called sequentially!* (from a single thread/fiber).
     *
-    * @param pongOnPing Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
+    * @param pongOnPing
+    *   Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
     */
   def receiveText(pongOnPing: Boolean = true): F[String] =
     receiveConcat(() => receiveTextFrame(pongOnPing), _ + _)
 
-  /** Receive a single binary message (which might come from multiple, fragmented frames).
-    * Ignores non-binary frames and returns combined results.
-    * Will fail with [[WebSocketClosed]] if the web socket is closed, or if a close frame is received.
+  /** Receive a single binary message (which might come from multiple, fragmented frames). Ignores non-binary frames and
+    * returns combined results. Will fail with [[WebSocketClosed]] if the web socket is closed, or if a close frame is
+    * received.
     *
     * *Should be only called sequentially!* (from a single thread/fiber).
     *
-    * @param pongOnPing Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
+    * @param pongOnPing
+    *   Should a [[WebSocketFrame.Pong]] be sent when a [[WebSocketFrame.Ping]] is received.
     */
   def receiveBinary(pongOnPing: Boolean): F[Array[Byte]] =
     receiveConcat(() => receiveBinaryFrame(pongOnPing), _ ++ _)
 
-  /** Extracts the received close frame (if available) as the left side of an either, or returns the original result
-    * on the right.
+  /** Extracts the received close frame (if available) as the left side of an either, or returns the original result on
+    * the right.
     *
     * Will fail with [[WebSocketClosed]] if the web socket is closed, but no close frame is available.
     *
-    * @param f The effect describing web socket interactions.
+    * @param f
+    *   The effect describing web socket interactions.
     */
   def eitherClose[T](f: => F[T]): F[Either[WebSocketFrame.Close, T]] =
     f.map(t => Right(t): Either[WebSocketFrame.Close, T]).handleError { case WebSocketClosed(Some(close)) =>
@@ -118,12 +123,13 @@ trait WebSocket[F[_]] {
 
   /** Returns an effect computing a:
     *
-    * - `Left` if the web socket is closed - optionally with the received close frame (if available).
-    * - `Right` with the original result otherwise.
+    *   - `Left` if the web socket is closed - optionally with the received close frame (if available).
+    *   - `Right` with the original result otherwise.
     *
     * Will never fail with a [[WebSocketClosed]].
     *
-    * @param f The effect describing web socket interactions.
+    * @param f
+    *   The effect describing web socket interactions.
     */
   def either[T](f: => F[T]): F[Either[Option[WebSocketFrame.Close], T]] =
     f.map(t => Right(t): Either[Option[WebSocketFrame.Close], T]).handleError { case WebSocketClosed(close) =>

ws/src/main/scala/sttp/ws/WebSocketException.scala

@@ -2,7 +2,8 @@ package sttp.ws
 
 abstract class WebSocketException(msg: String) extends Exception(msg)
 
-/** @param frame The received closing frame, if available.
+/** @param frame
+  *   The received closing frame, if available.
   */
 case class WebSocketClosed(frame: Option[WebSocketFrame.Close]) extends WebSocketException(null)
 

ws/src/main/scala/sttp/ws/WebSocketFrame.scala

@@ -13,17 +13,23 @@ object WebSocketFrame {
 
   /** A text frame with fragmentation or extension bits.
     *
-    * @param payload a text fragment.
-    * @param finalFragment flag indicating whether or not this is the final fragment
-    * @param rsv optional extension bits
+    * @param payload
+    *   a text fragment.
+    * @param finalFragment
+    *   flag indicating whether or not this is the final fragment
+    * @param rsv
+    *   optional extension bits
     */
   case class Text(payload: String, finalFragment: Boolean, rsv: Option[Int]) extends Data[String]
 
   /** A binary frame with fragmentation or extension bits.
     *
-    * @param payload a binary payload
-    * @param finalFragment flag indicating whether or not this is the last fragment
-    * @param rsv optional extension bits
+    * @param payload
+    *   a binary payload
+    * @param finalFragment
+    *   flag indicating whether or not this is the last fragment
+    * @param rsv
+    *   optional extension bits
     */
   case class Binary(payload: Array[Byte], finalFragment: Boolean, rsv: Option[Int]) extends Data[Array[Byte]]
 

ws/src/main/scala/sttp/ws/testing/WebSocketStub.scala

@@ -6,11 +6,10 @@ import sttp.ws.{WebSocket, WebSocketClosed, WebSocketFrame}
 
 import scala.util.{Failure, Success, Try}
 
-/** A stub for websockets that uses a queue of frames which are returned when the client calls
-  * [[WebSocket.receive]].
+/** A stub for websockets that uses a queue of frames which are returned when the client calls [[WebSocket.receive]].
   *
-  * New messages can be added to queue in reaction to [[WebSocket.send]] being invoked, by specifying the
-  * behavior using one of the [[thenRespond]] variants.
+  * New messages can be added to queue in reaction to [[WebSocket.send]] being invoked, by specifying the behavior using
+  * one of the [[thenRespond]] variants.
   *
   * For more complex cases, please provide your own implementation of [[WebSocket]].
   */
@@ -41,11 +40,11 @@ class WebSocketStub[S](
       (_, frame) => ((), addReceived(frame))
     )
 
-  /** Creates a stub that has the same initial responses, but replaces the function that adds responses to be
-    * received in reaction to [[WebSocket.send]] being invoked.
+  /** Creates a stub that has the same initial responses, but replaces the function that adds responses to be received
+    * in reaction to [[WebSocket.send]] being invoked.
     *
-    * More powerful version of [[thenRespond()]], as the given function can additionally use state and implement stateful
-    * logic for computing response messages.
+    * More powerful version of [[thenRespond()]], as the given function can additionally use state and implement
+    * stateful logic for computing response messages.
     */
   def thenRespondS[S2](initial: S2)(
       onSend: (S2, WebSocketFrame) => (S2, List[WebSocketFrame])
@@ -55,13 +54,13 @@ class WebSocketStub[S](
       (s2, lf.map(Try(_)))
     }
 
-  /** Creates a stub that has the same initial responses, but replaces the function that adds responses to be
-    * received in reaction to [[WebSocket.send]] being invoked.
+  /** Creates a stub that has the same initial responses, but replaces the function that adds responses to be received
+    * in reaction to [[WebSocket.send]] being invoked.
     *
     * More powerful version of:
-    * - [[thenRespond()]], as the given function can additionally use state and implement stateful
-    * logic for computing response messages.
-    * - [[thenRespondS()]] which allows receiving to fail with an exception.
+    *   - [[thenRespond()]], as the given function can additionally use state and implement stateful logic for computing
+    *     response messages.
+    *   - [[thenRespondS()]] which allows receiving to fail with an exception.
     */
   def thenRespondWithS[S2](initial: S2)(
       onSend: (S2, WebSocketFrame) => (S2, List[Try[WebSocketFrame]])
@@ -121,29 +120,29 @@ class WebSocketStub[S](
 
 object WebSocketStub {
 
-  /** Creates a stub which will return the given responses when [[WebSocket.receive]] is called by the client.
-    * More messages can be enqueued to be returned by the stub in response to [[WebSocket.send]] by subsequently
-    * calling one of the [[WebSocketStub.thenRespond]] methods.
+  /** Creates a stub which will return the given responses when [[WebSocket.receive]] is called by the client. More
+    * messages can be enqueued to be returned by the stub in response to [[WebSocket.send]] by subsequently calling one
+    * of the [[WebSocketStub.thenRespond]] methods.
     */
   def initialReceiveWith(
       events: List[Try[WebSocketFrame]]
   ): WebSocketStub[Unit] = {
     new WebSocketStub(events, (), (_, _) => ((), List.empty))
   }
 
-  /** Creates a stub which will return the given messages when [[WebSocket.receive]] is called by the client.
-    * More messages can be enqueued to be returned by the stub in response to [[WebSocket.send]] by subsequently
-    * calling one of the [[WebSocketStub.thenRespond]] methods.
+  /** Creates a stub which will return the given messages when [[WebSocket.receive]] is called by the client. More
+    * messages can be enqueued to be returned by the stub in response to [[WebSocket.send]] by subsequently calling one
+    * of the [[WebSocketStub.thenRespond]] methods.
     */
   def initialReceive(
       messages: List[WebSocketFrame]
   ): WebSocketStub[Unit] = {
     initialReceiveWith(messages.map(m => Success(m)))
   }
 
-  /** Creates a stub which won't return any initial frames when [[WebSocket.receive]] is called by the client.
-    * More messages can be enqueued to be returned by the stub in response to [[WebSocket.send]] by subsequently
-    * calling one of the [[WebSocketStub.thenRespond]] methods.
+  /** Creates a stub which won't return any initial frames when [[WebSocket.receive]] is called by the client. More
+    * messages can be enqueued to be returned by the stub in response to [[WebSocket.send]] by subsequently calling one
+    * of the [[WebSocketStub.thenRespond]] methods.
     */
   def noInitialReceive: WebSocketStub[Unit] = initialReceiveWith(List.empty)
 }