loading opening from Game, once, simplifies it all

Author: ornicar

app/controllers/Analyse.scala

@@ -59,12 +59,10 @@ object Analyse extends LilaController {
       Env.game.crosstableApi(pov.game) flatMap {
         case ((((pgn, analysis), tour), division), crosstable) =>
           Env.api.roundApi.watcher(pov, Env.api.version, tv = none, analysis.map(pgn -> _)) map { data =>
-            val opening = gameOpening(pov.game)
             Ok(html.analyse.replay(
               pov,
               data,
-              Env.analyse.annotator(pgn, analysis, opening, pov.game.winnerColor, pov.game.status, pov.game.clock).toString,
-              opening,
+              Env.analyse.annotator(pgn, analysis, pov.game.opening, pov.game.winnerColor, pov.game.status, pov.game.clock).toString,
               analysis,
               analysis filter (_.done) map { a => AdvantageChart(a.infoAdvices, pov.game.pgnMoves) },
               tour,
@@ -73,8 +71,4 @@ object Analyse extends LilaController {
               division))
           }
       }
-
-  private def gameOpening(game: GameModel) =
-    if (game.fromPosition || game.variant.exotic) none
-    else chess.OpeningExplorer openingOf game.pgnMoves
 }

app/controllers/Export.scala

@@ -19,7 +19,7 @@ object Export extends LilaController {
         case None => for {
           pgn ← Env.game.pgnDump(game)
           analysis ← (~get("as") != "raw") ?? (Env.analyse.analyser getDone game.id)
-        } yield Env.analyse.annotator(pgn, analysis, gameOpening(game), game.winnerColor, game.status, game.clock).toString
+        } yield Env.analyse.annotator(pgn, analysis, game.opening, game.winnerColor, game.status, game.clock).toString
       }) map { content =>
         Ok(content).withHeaders(
           CONTENT_TYPE -> ContentTypes.TEXT,

app/views/analyse/replay.scala.html

@@ -1,8 +1,8 @@
-@(pov: Pov, data: play.api.libs.json.JsObject, pgn: String, opening: Option[chess.OpeningExplorer.Opening], analysis: Option[lila.analyse.Analysis], advantageChart: Option[String], tour: Option[lila.tournament.Tournament], timeChart: lila.analyse.TimeChart, cross: Option[lila.game.Crosstable], division: lila.game.Divider.Division)(implicit ctx: Context)
+@(pov: Pov, data: play.api.libs.json.JsObject, pgn: String, analysis: Option[lila.analyse.Analysis], advantageChart: Option[String], tour: Option[lila.tournament.Tournament], timeChart: lila.analyse.TimeChart, cross: Option[lila.game.Crosstable], division: lila.game.Divider.Division)(implicit ctx: Context)
 
 @import pov._
 
-@title = @{ s"${playerText(pov.player)} vs ${playerText(pov.opponent)} in $gameId : ${opening.fold(trans.replayAndAnalyse.str())(_.fullName)}" }
+@title = @{ s"${playerText(pov.player)} vs ${playerText(pov.opponent)} in $gameId : ${game.opening.fold(trans.replayAndAnalyse.str())(_.fullName)}" }
 
 @moreCss = {
 @cssTag("analyse.css")

app/views/game/widgets.scala.html

@@ -60,7 +60,7 @@
     @if(g.turns > 0) {
     @defining(g openingPgnMoves 20) { pgnMoves =>
     @if(!g.fromPosition) {
-    @chess.OpeningExplorer.openingOf(pgnMoves).map { opening =>
+    @g.opening.map { opening =>
     <div class="opening">@opening.name</div>
     }
     }

modules/api/src/main/GameApi.scala

@@ -138,7 +138,7 @@ private[api] final class GameApi(
     "analysis" -> analysisOption.ifTrue(withAnalysis).|@|(pgnOption).apply(analysisApi.game),
     "moves" -> withMoves.option(g.pgnMoves mkString " "),
     "opening" -> withOpening.?? {
-      chess.OpeningExplorer.openingOf(g.pgnMoves) map { opening =>
+      g.opening map { opening =>
         Json.obj("code" -> opening.code, "name" -> opening.name)
       }
     },

modules/game/src/main/Game.scala

@@ -372,12 +372,15 @@ case class Game(
 
   def resetTurns = copy(turns = 0)
 
+  lazy val opening =
+    if (playable || fromPosition || variant.exotic) none
+    else chess.OpeningExplorer openingOf pgnMoves
+
   private def playerMaps[A](f: Player => Option[A]): List[A] = players.map(f).flatten
 }
 
 object Game {
 
-
   val analysableVariants: Set[Variant] = Set(Variant.Standard, Variant.Chess960, Variant.KingOfTheHill)
   val unanalysableVariants: Set[Variant] = Variant.all.toSet -- analysableVariants
 
@@ -511,7 +514,7 @@ object Game {
           pgnImport = r.getO[PgnImport](pgnImport)(PgnImport.pgnImportBSONHandler),
           tournamentId = r strO tournamentId,
           tvAt = r dateO tvAt,
-        analysed = r boolD analysed)
+          analysed = r boolD analysed)
       )
     }
 

modules/game/src/main/PgnDump.scala

@@ -49,9 +49,6 @@ final class PgnDump(
 
   private def tags(game: Game): Fu[List[Tag]] = gameLightUsers(game) match {
     case (wu, bu) =>
-      val opening: Option[OpeningExplorer.Opening] =
-        if (customStartPosition(game.variant)) none
-        else OpeningExplorer openingOf game.pgnMoves
       (game.variant.standard.fold(fuccess(none), GameRepo initialFen game.id)) map { initialFen =>
         List(
           Tag(_.Event, game.rated.fold("Rated game", "Casual game")),
@@ -65,8 +62,8 @@ final class PgnDump(
           Tag("PlyCount", game.turns),
           Tag(_.Variant, game.variant.name.capitalize),
           Tag(_.TimeControl, game.clock.fold("-") { c => s"${c.limit}+${c.increment}" }),
-          Tag(_.ECO, opening.fold("?")(_.code)),
-          Tag(_.Opening, opening.fold("?")(_.name))
+          Tag(_.ECO, game.opening.fold("?")(_.code)),
+          Tag(_.Opening, game.opening.fold("?")(_.name))
         ) ::: customStartPosition(game.variant).??(List(
             Tag(_.FEN, initialFen | "?"),
             Tag("SetUp", "1")

modules/gameSearch/src/main/Indexer.scala

@@ -111,7 +111,7 @@ private[gameSearch] final class Indexer(
         ai -> game.aiLevel,
         date -> (ElasticSearch.Date.formatter print game.createdAt).some,
         duration -> game.estimateTotalTime.some,
-        opening -> (chess.OpeningExplorer openingOf game.pgnMoves map (_.code.toLowerCase)),
+        opening -> (game.opening map (_.code.toLowerCase)),
         analysed -> hasAnalyse.some
       ).collect {
           case (key, Some(value)) => key -> value

modules/round/src/main/JsonView.scala

@@ -136,8 +136,6 @@ final class JsonView(
       UserRepo.pair(pov.player.userId, pov.opponent.userId) map {
         case (((initialFen, socket), chat), (playerUser, opponentUser)) =>
           import pov._
-          val opening = if (game.playable || initialFen.isDefined || game.fromPosition || game.variant.exotic) none
-          else chess.OpeningExplorer openingOf game.pgnMoves
           Json.obj(
             "game" -> Json.obj(
               "id" -> gameId,
@@ -156,7 +154,7 @@ final class JsonView(
               "rematch" -> game.next,
               "source" -> game.source.map(sourceJson),
               "moves" -> game.pgnMoves.mkString(" "),
-              "opening" -> opening.map { o =>
+              "opening" -> game.opening.map { o =>
                 Json.obj(
                   "code" -> o.code,
                   "name" -> o.name,