downgrade syntax, get everything to compile

.gitignore

@@ -12,7 +12,7 @@ logs
 data/*
 database
 project/target
-project/metals.sbt
+metals.sbt
 public/compiled/
 public/css/
 target

app/controllers/Swiss.scala

@@ -2,35 +2,31 @@ package controllers
 
 import play.api.mvc._
 
-import lila.api.Context
-import lila.app._
+import lidraughts.api.Context
+import lidraughts.app._
 import views._
 
-final class Swiss(
-    env: Env
-) extends LilaController(env) {
+object Swiss extends LidraughtsController {
+
+  private def env = Env.swiss
 
   def show(id: String) = Open { implicit ctx =>
     ???
   }
 
   def form(teamId: String) = Auth { implicit ctx => me =>
-    Ok(html.swiss.form.create(env.swiss.forms.create, teamId)).fuccess
+    Ok(html.swiss.form.create(env.forms.create, teamId)).fuccess
   }
 
   def create(teamId: String) = AuthBody { implicit ctx => me =>
-    env.team.teamRepo.isLeader(teamId, me.id) flatMap {
-      case false => notFound
-      case _ =>
-        env.swiss.forms.create
-          .bindFromRequest()(ctx.body)
-          .fold(
-            err => BadRequest(html.swiss.form.create(err, teamId)).fuccess,
-            data =>
-              env.swiss.api.create(data, me, teamId) map { swiss =>
-                Redirect(routes.Swiss.show(swiss.id.value))
-              }
-          )
-    }
+    env.forms.create
+      .bindFromRequest()(ctx.body)
+      .fold(
+        err => BadRequest(html.swiss.form.create(err, teamId)).fuccess,
+        data =>
+          env.api.create(data, me, teamId) map { swiss =>
+            Redirect(routes.Swiss.show(swiss.id.value))
+          }
+      )
   }
 }

app/views/swiss/form.scala

@@ -3,40 +3,40 @@ package views.html.swiss
 import play.api.data.Form
 
 import controllers.routes
-import lila.api.Context
-import lila.app.templating.Environment._
-import lila.tournament.{ DataForm => TourForm }
-import lila.swiss.SwissForm
-import lila.app.ui.ScalatagsTemplate._
-import lila.hub.LightTeam.TeamID
+import lidraughts.api.Context
+import lidraughts.app.templating.Environment._
+import lidraughts.tournament.{ DataForm => TourForm }
+import lidraughts.swiss.SwissForm
+import lidraughts.app.ui.ScalatagsTemplate._
+import lidraughts.hub.lightTeam.TeamId
 
 object form {
 
-  def create(form: Form[_], teamId: TeamID)(implicit ctx: Context) =
+  def create(form: Form[_], teamId: TeamId)(implicit ctx: Context) =
     views.html.base.layout(
       title = "New Swiss tournament",
       moreCss = cssTag("clas"),
       moreJs = jsAt("compiled/clas.js")
     ) {
-      val fields = new SwissFields(form)
-      main(cls := "page-small")(
-        div(cls := "swiss__form box box-pad")(
-          h1("New Swiss tournament"),
-          postForm(cls := "form3", action := routes.Swiss.create(teamId))(
-            fields.name,
-            form3.split(fields.rated, fields.variant),
-            fields.clock,
-            fields.description,
-            form3.globalError(form),
-            fields.startsAt,
-            form3.actions(
-              a(href := routes.Team.show(teamId))(trans.cancel()),
-              form3.submit(trans.createANewTournament(), icon = "g".some)
+        val fields = new SwissFields(form)
+        main(cls := "page-small")(
+          div(cls := "swiss__form box box-pad")(
+            h1("New Swiss tournament"),
+            postForm(cls := "form3", action := routes.Swiss.create(teamId))(
+              fields.name,
+              form3.split(fields.rated, fields.variant),
+              fields.clock,
+              fields.description,
+              form3.globalError(form),
+              fields.startsAt,
+              form3.actions(
+                a(href := routes.Team.show(teamId))(trans.cancel()),
+                form3.submit(trans.createANewTournament(), icon = "g".some)
+              )
             )
           )
         )
-      )
-    }
+      }
 }
 
 final private class SwissFields(form: Form[_])(implicit ctx: Context) {
@@ -70,7 +70,7 @@ final private class SwissFields(form: Form[_])(implicit ctx: Context) {
       form3.group(form("clock.limit"), trans.clockInitialTime(), half = true)(
         form3.select(_, TourForm.clockTimeChoices)
       ),
-      form3.group(form("clock.increment"), trans.clockIncrement(), half = true)(
+      form3.group(form("clock.increment"), trans.increment(), half = true)(
         form3.select(_, TourForm.clockIncrementChoices)
       )
     )

build.sbt

@@ -215,7 +215,7 @@ lazy val tournament = module("tournament", Seq(common, hub, socket, game, round,
   libraryDependencies ++= provided(play.api, scalatags, reactivemongo.driver, reactivemongo.iteratees)
 )
 
-lazy val swiss = module("swiss", Seq(common, hub, socket, game, round, security, chat, memo, i18n).settings(
+lazy val swiss = module("swiss", Seq(common, hub, socket, game, round, security, chat, memo, i18n)).settings(
   libraryDependencies ++= provided(play.api, reactivemongo.driver, scalatags)
 )
 

conf/base.conf

@@ -445,6 +445,12 @@ tournament {
   ranking.cache.ttl = 1 hour
   net.domain = ${net.domain}
 }
+swiss {
+  collection {
+    swiss = swiss
+    round = swiss_round
+  }
+}
 simul {
   collection {
     simul = simul

modules/common/src/main/Lidraughtsisms.scala

@@ -37,7 +37,6 @@ trait Lidraughtsisms
   with scalaz.syntax.ToValidationOps {
 
   type StringValue = lidraughts.base.LidraughtsTypes.StringValue
-  type IntValue = lidraughts.base.LidraughtsTypes.IntValue
 
   @inline implicit def toPimpedFuture[A](f: Fu[A]) = new PimpedFuture(f)
   @inline implicit def toPimpedFutureBoolean(f: Fu[Boolean]) = new PimpedFutureBoolean(f)

modules/swiss/src/main/BsonHandlers.scala

@@ -1,66 +1,47 @@
-package lila.swiss
+package lidraughts.swiss
 
-import chess.Clock.{ Config => ClockConfig }
-import chess.variant.Variant
-import chess.StartingPosition
-import lila.db.BSON
-import lila.db.dsl._
-import reactivemongo.api.bson._
+import draughts.Clock.{ Config => ClockConfig }
+import draughts.variant.Variant
+import lidraughts.db.BSON
+import lidraughts.db.dsl._
+import reactivemongo.bson._
 
 private object BsonHandlers {
 
-  implicit private[swiss] val statusHandler = tryHandler[Status](
-    { case BSONInteger(v) => Status(v) toTry s"No such status: $v" },
-    x => BSONInteger(x.id)
-  )
+  private[swiss] implicit val statusBSONHandler: BSONHandler[BSONInteger, Status] = new BSONHandler[BSONInteger, Status] {
+    def read(bsonInt: BSONInteger): Status = Status(bsonInt.value) err s"No such status: ${bsonInt.value}"
+    def write(x: Status) = BSONInteger(x.id)
+  }
+
+  implicit val clockHandler = new BSONHandler[BSONDocument, ClockConfig] {
+    def read(doc: BSONDocument) = ClockConfig(
+      doc.getAs[Int]("limit").get,
+      doc.getAs[Int]("increment").get
+    )
+
+    def write(config: ClockConfig) = BSONDocument(
+      "limit" -> config.limitSeconds,
+      "increment" -> config.incrementSeconds
+    )
+  }
+  implicit val variantHandler = new BSONHandler[BSONInteger, Variant] {
+    def read(b: BSONInteger): Variant = Variant.orDefault(b.value)
+    def write(x: Variant) = BSONInteger(x.id)
+  }
 
-  implicit val clockHandler = tryHandler[ClockConfig](
-    {
-      case doc: BSONDocument =>
-        for {
-          limit <- doc.getAsTry[Int]("limit")
-          inc   <- doc.getAsTry[Int]("increment")
-        } yield ClockConfig(limit, inc)
-    },
-    c =>
-      BSONDocument(
-        "limit"     -> c.limitSeconds,
-        "increment" -> c.incrementSeconds
-      )
-  )
-  implicit val variantHandler = lila.db.dsl.quickHandler[Variant](
-    {
-      case BSONString(v) => Variant orDefault v
-      case _             => Variant.default
-    },
-    v => BSONString(v.key)
-  )
-  private lazy val fenIndex: Map[String, StartingPosition] = StartingPosition.all.view.map { p =>
-    p.fen -> p
-  }.toMap
-  implicit val startingPositionHandler = lila.db.dsl.quickHandler[StartingPosition](
-    {
-      case BSONString(v) => fenIndex.getOrElse(v, StartingPosition.initial)
-      case _             => StartingPosition.initial
-    },
-    v => BSONString(v.fen)
-  )
   implicit val swissPointsHandler = intAnyValHandler[Swiss.Points](_.double, Swiss.Points.apply)
 
   implicit val playerNumberHandler = intAnyValHandler[SwissPlayer.Number](_.value, SwissPlayer.Number.apply)
-  implicit val playerIdHandler = tryHandler[SwissPlayer.Id](
-    {
-      case BSONString(v) =>
-        (v split ':' match {
-          case Array(swissId, number) =>
-            number.toIntOption map { n =>
-              SwissPlayer.Id(Swiss.Id(swissId), SwissPlayer.Number(n))
-            }
-          case _ => None
-        }) toTry s"Invalid player ID $v"
-    },
-    id => BSONString(s"${id.swissId}:${id.number}")
-  )
+  implicit val playerIdHandler = new BSONHandler[BSONString, SwissPlayer.Id] {
+    def read(b: BSONString): SwissPlayer.Id = (b.value split ':' match {
+      case Array(swissId, number) =>
+        parseIntOption(number) map { n =>
+          SwissPlayer.Id(Swiss.Id(swissId), SwissPlayer.Number(n))
+        }
+      case _ => None
+    }) err s"Invalid player ID $b"
+    def write(id: SwissPlayer.Id) = BSONString(s"${id.swissId}:${id.number}")
+  }
 
   implicit val playerHandler = new BSON[SwissPlayer] {
     def reads(r: BSON.Reader) = SwissPlayer(
@@ -73,9 +54,9 @@ private object BsonHandlers {
     def writes(w: BSON.Writer, o: SwissPlayer) = $doc(
       "_id" -> o.id,
       "uid" -> o.userId,
-      "r"   -> o.rating,
-      "pr"  -> w.boolO(o.provisional),
-      "p"   -> o.points
+      "r" -> o.rating,
+      "pr" -> w.boolO(o.provisional),
+      "p" -> o.points
     )
   }
 
@@ -89,7 +70,7 @@ private object BsonHandlers {
         black = black,
         winner = r boolO "w" map {
           case true => white
-          case _    => black
+          case _ => black
         }
       )
     }
@@ -102,34 +83,31 @@ private object BsonHandlers {
   }
 
   implicit val roundNumberHandler = intAnyValHandler[SwissRound.Number](_.value, SwissRound.Number.apply)
-  implicit val roundIdHandler = tryHandler[SwissRound.Id](
-    {
-      case BSONString(v) =>
-        (v split ':' match {
-          case Array(swissId, number) =>
-            number.toIntOption map { n =>
-              SwissRound.Id(Swiss.Id(swissId), SwissRound.Number(n))
-            }
-          case _ => None
-        }) toTry s"Invalid round ID $v"
-    },
-    id => BSONString(id.toString)
-  )
+  implicit val roundIdHandler = new BSONHandler[BSONString, SwissRound.Id] {
+    def read(b: BSONString): SwissRound.Id = (b.value split ':' match {
+      case Array(swissId, number) =>
+        parseIntOption(number) map { n =>
+          SwissRound.Id(Swiss.Id(swissId), SwissRound.Number(n))
+        }
+      case _ => None
+    }) err s"Invalid round ID $b"
+    def write(id: SwissRound.Id) = BSONString(id.toString)
+  }
 
   implicit val roundHandler = new BSON[SwissRound] {
     def reads(r: BSON.Reader) =
       SwissRound(
         id = r.get[SwissRound.Id]("_id"),
         pairings = r.get[List[SwissPairing]]("p")
-        // byes = r.get[List[SwissPlayer.Number]]("b")
+      // byes = r.get[List[SwissPlayer.Number]]("b")
       )
     def writes(w: BSON.Writer, o: SwissRound) = $doc(
       "id" -> o.id,
-      "p"  -> o.pairings
-      // "b"  -> o.byes
+      "p" -> o.pairings
+    // "b"  -> o.byes
     )
   }
 
   implicit val swissIdHandler = stringAnyValHandler[Swiss.Id](_.value, Swiss.Id.apply)
-  implicit val swissHandler   = Macros.handler[Swiss]
+  implicit val swissHandler = Macros.handler[Swiss]
 }

modules/swiss/src/main/Env.scala

@@ -1,22 +1,33 @@
-package lila.swiss
+package lidraughts.swiss
 
-import com.softwaremill.macwire._
+import com.typesafe.config.Config
 
-import lila.common.config._
-
-@Module
 final class Env(
-    db: lila.db.Db
-)(implicit ec: scala.concurrent.ExecutionContext) {
+    config: Config,
+    db: lidraughts.db.Env
+) {
+
+  private val settings = new {
+    val CollectionSwiss = config getString "collection.swiss"
+    val CollectionRound = config getString "collection.round"
+  }
+  import settings._
 
-  private val colls = wire[SwissColls]
+  lazy val api = new SwissApi(
+    swissColl = swissColl,
+    roundColl = roundColl
+  )
 
-  val api = wire[SwissApi]
+  lazy val forms = new SwissForm
 
-  lazy val forms = wire[SwissForm]
+  private[swiss] lazy val swissColl = db(CollectionSwiss)
+  private[swiss] lazy val roundColl = db(CollectionRound)
 }
 
-private class SwissColls(db: lila.db.Db) {
-  val swiss = db(CollName("swiss"))
-  val round = db(CollName("swiss_round"))
+object Env {
+
+  lazy val current = "swiss" boot new Env(
+    config = lidraughts.common.PlayApp loadConfig "swiss",
+    db = lidraughts.db.Env.current
+  )
 }