Patch updates

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Scala Steward: Reformat with scalafmt 3.9.7
+a96d5f7d3af36622559ad49f66a986c103680e91

.scalafmt.conf

@@ -13,4 +13,4 @@ rewrite.rules = [ AvoidInfix, ExpandImportSelectors, RedundantParens, SortModifi
 rewrite.sortModifiers.order = [ "private", "protected", "final", "sealed", "abstract", "implicit", "override", "lazy" ]
 spaces.inImportCurlyBraces = true   # more idiomatic to include whitepsace in import x.{ yyy }
 trailingCommas = preserve
-version = 3.9.6
+version = 3.9.7

build.sbt

@@ -22,7 +22,7 @@ lazy val cachecontrol = (project in file("."))
       slf4jSimple % Test
     ),
     mimaPreviousArtifacts := previousVersion.map(organization.value %% moduleName.value % _).toSet,
-    headerLicense := {
+    headerLicense         := {
       Some(
         HeaderLicense.Custom(
           s"Copyright (C) from 2022 The Play Framework Contributors <https://github.com/playframework>, 2011-2021 Lightbend Inc. <https://www.lightbend.com>"

src/main/scala/org/playframework/cachecontrol/CacheDefaults.scala

@@ -116,7 +116,7 @@ trait CacheDefaults extends Cache {
     while (nominatedHeadersIter.hasNext) {
       val nominatedHeaderName = nominatedHeadersIter.next()
       presentedHeaders.get(nominatedHeaderName) match {
-        case None => return false
+        case None                        => return false
         case Some(presentedHeaderValues) =>
           val nominatedHeaderValues = nominatedHeaders(nominatedHeaderName)
           // There's a list of header values, so we need a way to normalize it.

src/main/scala/org/playframework/cachecontrol/CacheDirectiveParser.scala

@@ -53,9 +53,9 @@ object CacheDirectiveParser {
      *
      * These patterns are translated directly using the same naming
      */
-    val ctl  = acceptIf { c => (c >= 0 && c <= 0x1f) || c.toInt == 0x7f }(_ => "Expected a control character")
-    val char = acceptIf(_ < 0x80)(_ => "Expected an ascii character")
-    val text = not(ctl) ~> any
+    val ctl        = acceptIf { c => (c >= 0 && c <= 0x1f) || c.toInt == 0x7f }(_ => "Expected a control character")
+    val char       = acceptIf(_ < 0x80)(_ => "Expected an ascii character")
+    val text       = not(ctl) ~> any
     val separators = {
       acceptIf(c => separatorBitSet(c.toInt))(_ => "Expected one of " + separatorChars)
     }

src/main/scala/org/playframework/cachecontrol/CacheDirectiveParserCompat.scala

@@ -8,7 +8,7 @@ object CacheDirectiveParserCompat {
   def toImmutableSeq[T](seq: Seq[T]): scala.collection.immutable.Seq[T] = {
     seq match {
       case xs: scala.collection.immutable.Seq[T @unchecked] => xs
-      case _ =>
+      case _                                                =>
         val b = scala.collection.immutable.Seq.newBuilder[T]
         seq.iterator.foreach(b += _)
         b.result()

src/test/scala/org/playframework/cachecontrol/CacheDirectiveParserSpec.scala

@@ -154,7 +154,7 @@ class CacheDirectiveParserSpec extends AnyWordSpec {
 
     "parse random input as cache directives" in {
       // include embedded commas to make things interesting...
-      val directives = CacheDirectiveParser.parse(Seq("""i,  have, no=idea,  what="I'm, doing""""))
+      val directives  = CacheDirectiveParser.parse(Seq("""i,  have, no=idea,  what="I'm, doing""""))
       val badSequence = Seq(
         CacheDirectiveExtension("i", None),
         CacheDirectiveExtension("have", None),

src/test/scala/org/playframework/cachecontrol/ResponseCachingCalculatorSpec.scala

@@ -173,10 +173,10 @@ class ResponseCachingCalculatorSpec extends AnyWordSpec {
     "with qualified private and qualified no-cache response directives" should {
       "return DoCache with only no-cache stripped headers when private" in {
         import CacheDirectives._
-        val policy                = new ResponseCachingCalculator(privateCache)
-        val request: CacheRequest = defaultRequest
-        val noCache               = NoCache(Some(List("Set-Cookie")))
-        val privDirective         = Private(Some(List("Some-Header")))
+        val policy                   = new ResponseCachingCalculator(privateCache)
+        val request: CacheRequest    = defaultRequest
+        val noCache                  = NoCache(Some(List("Set-Cookie")))
+        val privDirective            = Private(Some(List("Some-Header")))
         val response: OriginResponse =
           defaultResponse.copy(headers = h(privDirective.toString + "," + noCache.toString))
         val result = policy.isCacheable(request, response)
@@ -185,10 +185,10 @@ class ResponseCachingCalculatorSpec extends AnyWordSpec {
 
       "return DoCache with both stripped headers when shared cache" in {
         import CacheDirectives._
-        val policy                = new ResponseCachingCalculator(sharedCache)
-        val request: CacheRequest = defaultRequest
-        val noCache               = NoCache(Some(List("Set-Cookie")))
-        val privDirective         = Private(Some(List("Some-Header")))
+        val policy                   = new ResponseCachingCalculator(sharedCache)
+        val request: CacheRequest    = defaultRequest
+        val noCache                  = NoCache(Some(List("Set-Cookie")))
+        val privDirective            = Private(Some(List("Some-Header")))
         val response: OriginResponse =
           defaultResponse.copy(headers = h(privDirective.toString + "," + noCache.toString))
         val result = policy.isCacheable(request, response)
@@ -241,7 +241,7 @@ class ResponseCachingCalculatorSpec extends AnyWordSpec {
 
     "with a containsCachableExtension" should {
       "return DoCacheResponse" in {
-        var called = false
+        var called              = false
         val cacheWithExtensions = new StubCache(shared = false) {
           override def isCacheableExtension(extension: CacheDirectives.CacheDirectiveExtension): Boolean = {
             called = extension.name == "public-on-tuesday"

src/test/scala/org/playframework/cachecontrol/ResponseSelectionCalculatorSpec.scala

@@ -113,7 +113,7 @@ class ResponseSelectionCalculatorSpec extends AnyWordSpec {
         val policy            = new ResponseSelectionCalculator(cache)
         val presentingHeaders = Map(HeaderName("X-Custom-Header") -> Seq("value1"))
         val request           = defaultRequest.copy(headers = presentingHeaders)
-        val nominatedHeaders =
+        val nominatedHeaders  =
           Map(HeaderName("X-Custom-Header") -> Seq("value1"), HeaderName("X-Custom-Header") -> Seq("value2"))
         val response = defaultResponse.copy(nominatedHeaders = nominatedHeaders)
         val action   = policy.selectResponse(request, Seq(response))

src/test/scala/org/playframework/cachecontrol/ResponseServingcalculatorSpec.scala

@@ -44,7 +44,7 @@ class ResponseServingCalculatorSpec extends AnyWordSpec {
       "return Validate" in {
         val policy = new ResponseServingCalculator(privateCache)
 
-        val request = defaultRequest.copy(headers = defaultRequest.headers ++ Map(`Cache-Control` -> Seq("no-cache")))
+        val request  = defaultRequest.copy(headers = defaultRequest.headers ++ Map(`Cache-Control` -> Seq("no-cache")))
         val response =
           defaultResponse.copy(headers = defaultResponse.headers ++ Map(`Cache-Control` -> Seq("max-age=60")))
 
@@ -58,12 +58,12 @@ class ResponseServingCalculatorSpec extends AnyWordSpec {
       "return Validate" in {
         val policy = new ResponseServingCalculator(privateCache)
 
-        val request = defaultRequest.copy(headers = defaultRequest.headers ++ Map(`Pragma` -> Seq("no-cache")))
+        val request  = defaultRequest.copy(headers = defaultRequest.headers ++ Map(`Pragma` -> Seq("no-cache")))
         val response =
           defaultResponse.copy(headers = defaultResponse.headers ++ Map(`Cache-Control` -> Seq("max-age=60")))
 
         val action: ResponseServeAction = policy.serveResponse(request, response, Duration.ofSeconds(5))
-        val msg =
+        val msg                         =
           "Request does not contain Cache-Control header found, but does contains no-cache Pragma header, validation required"
         action should be(Validate(msg))
       }
@@ -73,7 +73,7 @@ class ResponseServingCalculatorSpec extends AnyWordSpec {
       "return ServeFresh when fresh" in {
         val policy = new ResponseServingCalculator(privateCache)
 
-        val request = defaultRequest.copy(headers = defaultRequest.headers ++ Map(`Cache-Control` -> Seq("no-store")))
+        val request  = defaultRequest.copy(headers = defaultRequest.headers ++ Map(`Cache-Control` -> Seq("no-store")))
         val response =
           defaultResponse.copy(headers = defaultResponse.headers ++ Map(`Cache-Control` -> Seq("publish,max-age=60")))
 
@@ -85,7 +85,7 @@ class ResponseServingCalculatorSpec extends AnyWordSpec {
       "return Validate when stale" in {
         val policy = new ResponseServingCalculator(privateCache)
 
-        val request = defaultRequest.copy(headers = defaultRequest.headers ++ Map(`Cache-Control` -> Seq("no-store")))
+        val request  = defaultRequest.copy(headers = defaultRequest.headers ++ Map(`Cache-Control` -> Seq("no-store")))
         val response =
           defaultResponse.copy(headers = defaultResponse.headers ++ Map(`Cache-Control` -> Seq("publish,max-age=60")))
 

src/test/scala/org/playframework/cachecontrol/SecondaryKeyCalculatorSpec.scala

@@ -12,8 +12,8 @@ import org.scalatest.wordspec.AnyWordSpec
 
 class SecondaryKeyCalculatorSpec extends AnyWordSpec {
   def responseHeaders = {
-    val now = HttpDate.now
-    val age = Duration.ofSeconds(60)
+    val now     = HttpDate.now
+    val age     = Duration.ofSeconds(60)
     val headers = Map(
       `Date`                         -> Seq(HttpDate.format(now)),
       `Age`                          -> Seq(age.getSeconds.toString),