Rewrite infix

.git-blame-ignore-revs

@@ -41,4 +41,8 @@ eea12a89f8550d74518f19ec9cda404e3f73b3d0
 6fb1e4363f3ed03acbf7aaffa10c63bc591a099f
 
 # prettier 3.0.1 update from 2.x
-72d993c45d9b9d17395e0f0a2726af325ef0621c
+72d993c45d9b9d17395e0f0a2726af325ef0621c
+
+# scalafmt AvoidInfix rewrite
+5e0ecbebe4f43ed6744f8ec4f67ea66fae28fde6
+7b5eb9197e2436eb9002a64e100c0a43f562fb30

.scalafmt.conf

@@ -9,6 +9,7 @@ rewrite.redundantBraces.stringInterpolation = true
 
 rewrite.scala3.convertToNewSyntax = yes
 rewrite.scala3.removeOptionalBraces = yes
+rewrite.rules = [AvoidInfix]
 
 fileOverride {
   "glob:**/build.sbt" {

app/Env.scala

@@ -149,10 +149,11 @@ final class Env(
     Future {
       puzzle.daily.get
     }.flatMap(identity)
-      .withTimeoutDefault(50.millis, none) recover { case e: Exception =>
-      lila.log("preloader").warn("daily puzzle", e)
-      none
-    }
+      .withTimeoutDefault(50.millis, none)
+      .recover { case e: Exception =>
+        lila.log("preloader").warn("daily puzzle", e)
+        none
+      }
 
   system.actorOf(Props(new templating.RendererActor), name = config.get[String]("hub.actor.renderer"))
 end Env
@@ -257,4 +258,4 @@ final class EnvBoot(
     lila.log("boot").info(s"Loaded lila modules in ${c.showDuration}")
     c.result
 
-  templating.Environment setEnv env
+  templating.Environment.setEnv(env)

app/controllers/Account.scala

@@ -22,12 +22,12 @@ final class Account(
 
   def profile = Auth { _ ?=> me ?=>
     Ok.page:
-      html.account.profile(me, env.user.forms profileOf me)
+      html.account.profile(me, env.user.forms.profileOf(me))
   }
 
   def username = Auth { _ ?=> me ?=>
     Ok.page:
-      html.account.username(me, env.user.forms usernameOf me)
+      html.account.username(me, env.user.forms.usernameOf(me))
   }
 
   def profileApply = AuthOrScopedBody(_.Web.Mobile) { _ ?=> me ?=>
@@ -52,31 +52,33 @@ final class Account(
             _ <- env.user.forms.flair.bindFromRequest().fold(_ => funit, env.user.repo.setFlair(me, _))
           yield
             env.user.lightUserApi.invalidate(me)
-            Redirect(routes.User show me.username).flashSuccess
+            Redirect(routes.User.show(me.username)).flashSuccess
       )
   }
 
   def usernameApply = AuthBody { _ ?=> me ?=>
     FormFuResult(env.user.forms.username(me))(err => renderPage(html.account.username(me, err))): username =>
-      env.user.repo.setUsernameCased(me, username) inject
-        Redirect(routes.User show me.username).flashSuccess recover { case e =>
+      env.user.repo
+        .setUsernameCased(me, username)
+        .inject(Redirect(routes.User.show(me.username)).flashSuccess)
+        .recover { case e =>
           Redirect(routes.Account.username).flashFailure(e.getMessage)
         }
   }
 
   def info = Auth { ctx ?=> me ?=>
     negotiateJson:
       for
-        povs         <- env.round.proxyRepo urgentGames me
-        nbChallenges <- env.challenge.api.countInFor get me
-        playban      <- env.playban.api currentBan me
+        povs         <- env.round.proxyRepo.urgentGames(me)
+        nbChallenges <- env.challenge.api.countInFor.get(me)
+        playban      <- env.playban.api.currentBan(me)
         perfs        <- ctx.pref.showRatings.soFu(env.user.perfsRepo.perfsOf(me))
       yield Ok:
         env.user.jsonView
           .full(me, perfs, withProfile = false) ++ Json
           .obj(
             "prefs" -> lila.pref.JsonView.write(ctx.pref, lichobileCompat = HTTPRequest.isLichobile(req)),
-            "nowPlaying"   -> JsArray(povs take 50 map env.api.lobbyApi.nowPlaying),
+            "nowPlaying"   -> JsArray(povs.take(50).map(env.api.lobbyApi.nowPlaying)),
             "nbChallenges" -> nbChallenges,
             "online"       -> true
           )
@@ -100,12 +102,14 @@ final class Account(
       if getBool("wiki") && !wikiGranted then Unauthorized(jsonError("Wiki access not granted"))
       else
         rateLimit(me, limited):
-          env.api.userApi.extended(
-            me.value,
-            withFollows = apiC.userWithFollows,
-            withTrophies = false,
-            forWiki = wikiGranted
-          ) dmap { JsonOk(_) }
+          env.api.userApi
+            .extended(
+              me.value,
+              withFollows = apiC.userWithFollows,
+              withTrophies = false,
+              forWiki = wikiGranted
+            )
+            .dmap { JsonOk(_) }
     }
 
   def apiNowPlaying = Scoped()(doNowPlaying)
@@ -114,20 +118,22 @@ final class Account(
     env.round.proxyRepo
       .urgentGames(me)
       .map:
-        _.take((getInt("nb") | 9) atMost 50)
+        _.take((getInt("nb") | 9).atMost(50))
       .map:
-        _.filterNot(_.game.isTournament) map env.api.lobbyApi.nowPlaying
+        _.filterNot(_.game.isTournament).map(env.api.lobbyApi.nowPlaying)
       .map: povs =>
         Ok(Json.obj("nowPlaying" -> JsArray(povs)))
 
   def dasher = Auth { _ ?=> me ?=>
     negotiateJson:
-      env.pref.api.get(me) map: prefs =>
-        Ok:
-          lila.common.LightUser.write(me.light) ++ Json.obj(
-            "coach" -> isGranted(_.Coach),
-            "prefs" -> lila.pref.JsonView.write(prefs, lichobileCompat = false)
-          )
+      env.pref.api
+        .get(me)
+        .map: prefs =>
+          Ok:
+            lila.common.LightUser.write(me.light) ++ Json.obj(
+              "coach" -> isGranted(_.Coach),
+              "prefs" -> lila.pref.JsonView.write(prefs, lichobileCompat = false)
+            )
   }
 
   def passwd = Auth { _ ?=> me ?=>
@@ -144,45 +150,47 @@ final class Account(
   }
 
   private def refreshSessionId(result: Result)(using ctx: Context, me: Me): Fu[Result] =
-    env.security.store.closeAllSessionsOf(me) >>
+    (env.security.store.closeAllSessionsOf(me) >>
       env.push.webSubscriptionApi.unsubscribeByUser(me) >>
       env.push.unregisterDevices(me) >>
-      env.security.api.saveAuthentication(me, ctx.mobileApiVersion) map { sessionId =>
-        result.withCookies(env.lilaCookie.session(env.security.api.sessionIdKey, sessionId))
-      }
+      env.security.api.saveAuthentication(me, ctx.mobileApiVersion)).map { sessionId =>
+      result.withCookies(env.lilaCookie.session(env.security.api.sessionIdKey, sessionId))
+    }
 
   private def emailForm(using me: Me) =
-    env.user.repo email me flatMap env.security.forms.changeEmail
+    env.user.repo.email(me).flatMap(env.security.forms.changeEmail)
 
   def email = Auth { _ ?=> me ?=>
     if getBool("check")
-    then Ok async renderCheckYourEmail
+    then Ok.async(renderCheckYourEmail)
     else emailForm.flatMap(f => Ok.page(html.account.email(f)))
   }
 
   def apiEmail = Scoped(_.Email.Read) { _ ?=> me ?=>
-    Found(env.user.repo email me): email =>
+    Found(env.user.repo.email(me)): email =>
       JsonOk(Json.obj("email" -> email.value))
   }
 
   def renderCheckYourEmail(using Context): Fu[Frag] =
     renderPage:
-      html.auth.checkYourEmail(lila.security.EmailConfirm.cookie get ctx.req)
+      html.auth.checkYourEmail(lila.security.EmailConfirm.cookie.get(ctx.req))
 
   def emailApply = AuthBody { ctx ?=> me ?=>
     auth.HasherRateLimit:
       env.security.forms.preloadEmailDns() >> emailForm.flatMap: form =>
         FormFuResult(form)(err => renderPage(html.account.email(err))): data =>
           val newUserEmail = lila.security.EmailConfirm.UserEmail(me.username, data.email)
           auth.EmailConfirmRateLimit(newUserEmail, ctx.req, rateLimited):
-            env.security.emailChange.send(me, newUserEmail.email) inject
-              Redirect(routes.Account.email).flashSuccess:
+            env.security.emailChange
+              .send(me, newUserEmail.email)
+              .inject(Redirect(routes.Account.email).flashSuccess:
                 lila.i18n.I18nKeys.checkYourEmail.txt()
+              )
   }
 
   def emailConfirm(token: String) = Open:
     Found(env.security.emailChange.confirm(token)): (user, prevEmail) =>
-      (prevEmail.exists(_.isNoReply) so env.clas.api.student.release(user)) >>
+      (prevEmail.exists(_.isNoReply).so(env.clas.api.student.release(user))) >>
         auth.authenticateUser(
           user,
           remember = true,
@@ -206,7 +214,7 @@ final class Account(
             err => BadRequest.page(html.account.emailConfirmHelp(err, none)),
             username =>
               getStatus(env.user.api, env.user.repo, username).flatMap: status =>
-                Ok.page(html.account.emailConfirmHelp(helpForm fill username, status.some))
+                Ok.page(html.account.emailConfirmHelp(helpForm.fill(username), status.some))
           )
 
   def twoFactor = Auth { _ ?=> me ?=>
@@ -231,8 +239,7 @@ final class Account(
     auth.HasherRateLimit:
       env.security.forms.disableTwoFactor.flatMap: form =>
         FormFuResult(form)(err => renderPage(html.account.twoFactor.disable(err))): _ =>
-          env.user.repo.disableTwoFactor(me) inject
-            Redirect(routes.Account.twoFactor).flashSuccess
+          env.user.repo.disableTwoFactor(me).inject(Redirect(routes.Account.twoFactor).flashSuccess)
   }
 
   def network(usingAltSocket: Option[Boolean]) = Auth { _ ?=> _ ?=>
@@ -242,7 +249,7 @@ final class Account(
   }
 
   def close = Auth { _ ?=> me ?=>
-    env.clas.api.student.isManaged(me) flatMap { managed =>
+    env.clas.api.student.isManaged(me).flatMap { managed =>
       env.security.forms.closeAccount.flatMap: form =>
         Ok.page(html.account.close(form, managed))
     }
@@ -256,7 +263,7 @@ final class Account(
             env.api.accountClosure
               .close(me.value)
               .inject:
-                Redirect(routes.User show me.username) withCookies env.lilaCookie.newSession
+                Redirect(routes.User.show(me.username)).withCookies(env.lilaCookie.newSession)
   }
 
   def kid = Auth { _ ?=> me ?=>
@@ -293,7 +300,7 @@ final class Account(
   def apiKidPost = Scoped(_.Preference.Write) { ctx ?=> me ?=>
     getBoolOpt("v") match
       case None    => BadRequest(jsonError("Missing v parameter"))
-      case Some(v) => env.user.repo.setKid(me, v) inject jsonOkResult
+      case Some(v) => env.user.repo.setKid(me, v).inject(jsonOkResult)
   }
 
   def security = Auth { _ ?=> me ?=>
@@ -312,8 +319,8 @@ final class Account(
     if sessionId == "all"
     then refreshSessionId(Redirect(routes.Account.security).flashSuccess)
     else
-      env.security.store.closeUserAndSessionId(me, sessionId) >>
-        env.push.webSubscriptionApi.unsubscribeBySession(sessionId) inject NoContent
+      (env.security.store.closeUserAndSessionId(me, sessionId) >>
+        env.push.webSubscriptionApi.unsubscribeBySession(sessionId)).inject(NoContent)
   }
 
   private def renderReopen(form: Option[Form[Reopen]], msg: Option[String])(using
@@ -325,44 +332,48 @@ final class Account(
 
   def reopen = Open:
     auth.RedirectToProfileIfLoggedIn:
-      Ok async renderReopen(none, none)
+      Ok.async(renderReopen(none, none))
 
   def reopenApply = OpenBody:
-    env.security.hcaptcha.verify() flatMap { captcha =>
+    env.security.hcaptcha.verify().flatMap { captcha =>
       if captcha.ok then
         env.security.forms.reopen.flatMap:
           _.form
             .bindFromRequest()
             .fold(
-              err => renderReopen(err.some, none) map { BadRequest(_) },
+              err => renderReopen(err.some, none).map { BadRequest(_) },
               data =>
                 env.security.reopen
-                  .prepare(data.username, data.email, env.mod.logApi.closedByMod) flatMap {
-                  case Left((code, msg)) =>
-                    lila.mon.user.auth.reopenRequest(code).increment()
-                    renderReopen(none, msg.some) map { BadRequest(_) }
-                  case Right(user) =>
-                    auth.MagicLinkRateLimit(user, data.email, ctx.req, rateLimited):
-                      lila.mon.user.auth.reopenRequest("success").increment()
-                      env.security.reopen.send(user, data.email) inject Redirect:
-                        routes.Account.reopenSent
-                }
+                  .prepare(data.username, data.email, env.mod.logApi.closedByMod)
+                  .flatMap {
+                    case Left((code, msg)) =>
+                      lila.mon.user.auth.reopenRequest(code).increment()
+                      renderReopen(none, msg.some).map { BadRequest(_) }
+                    case Right(user) =>
+                      auth.MagicLinkRateLimit(user, data.email, ctx.req, rateLimited):
+                        lila.mon.user.auth.reopenRequest("success").increment()
+                        env.security.reopen
+                          .send(user, data.email)
+                          .inject(Redirect:
+                            routes.Account.reopenSent
+                          )
+                  }
             )
-      else renderReopen(none, none) map { BadRequest(_) }
+      else renderReopen(none, none).map { BadRequest(_) }
     }
 
   def reopenSent = Open:
     Ok.page(html.account.reopen.sent)
 
   def reopenLogin(token: String) = Open:
-    env.security.reopen confirm token flatMap {
+    env.security.reopen.confirm(token).flatMap {
       case None =>
         lila.mon.user.auth.reopenConfirm("token_fail").increment()
         notFound
       case Some(user) =>
-        env.report.api.reopenReports(lila.report.Suspect(user)) >>
-          auth.authenticateUser(user, remember = true) andDo
-          lila.mon.user.auth.reopenConfirm("success").increment()
+        (env.report.api.reopenReports(lila.report.Suspect(user)) >>
+          auth.authenticateUser(user, remember = true))
+          .andDo(lila.mon.user.auth.reopenConfirm("success").increment())
     }
 
   def data = Auth { _ ?=> me ?=>