scala - instalar - play framework starter

- Activación de importación sin uso en el archivo de rutas de reproducción

Question

Quiero poder utilizar -Xfatal-warnings y -Ywarn-unused-import , el problema es que el compilador está generando un error en el archivo que contiene las rutas de reproducción para mi aplicación:

[error] /path/to/app/conf/routes: Unused import
[error] /path/to/app/conf/routes: Unused import
[error] /path/to/app/conf/routes:1: Unused import
[error] GET        /document/:id        my.app.controllers.MyController.getById(id: Int)

Lo mismo ocurre con otras rutas.

¿Es posible que le diga a Scalac que ignore un archivo?

La versión de Scala es 2.11.8 .

Answer 1

Acabo de encontrar el mismo problema con Scala 2.12 y Play 2.6 (que probablemente esté usando ahora).

Un complemento del compilador de Scala llamado Silencer lo ordena: https://github.com/ghik/silencer

Agregue la siguiente dependencia en build.sbt:

val silencerVersion = "1.2.1"

libraryDependencies ++= Seq(
    compilerPlugin("com.github.ghik" %% "silencer-plugin" % silencerVersion),
    "com.github.ghik" %% "silencer-lib" % silencerVersion % Provided
)

Luego agregue (también en build.sbt):

scalacOptions += "-P:silencer:globalFilters=Unused import"

El texto después de globalFilters= es una lista de coincidencias de globalFilters= regulares para silenciar las advertencias del compilador, se pueden separar con comas. Es posible que necesite modificar la expresión regular para su propio caso, pero el ejemplo anterior funcionó bien.

Significa que silencia las advertencias de "Importación no utilizada", pero si tiene la costumbre de formatear automáticamente su código ( ctrl+alt+L en Intellij), incluida la ordenación de importaciones no utilizadas, entonces no debería causar una problema.

Answer 2

Aquí hay otra opción (posiblemente inferior a la de danielnixon)

build.sbt siguiente a build.sbt :

import CustomGenerator._

import play.sbt.routes.RoutesKeys
RoutesKeys.routesImport := Seq.empty
routesGenerator := ModifiedInjectedRoutesGenerator

Luego agregó esto al project/CustomGenerator.scala (siempre project/ nivel superior project/ ):

object CustomGenerator {
  object ModifiedInjectedRoutesGenerator extends play.routes.compiler.RoutesGenerator {
    import play.routes.compiler._
    import play.routes.compiler.RoutesCompiler.RoutesCompilerTask

    def generate(task: RoutesCompilerTask, namespace: Option[String], rules: List[Rule]): Seq[(String, String)] = {
      play.routes.compiler.InjectedRoutesGenerator.generate(task, namespace, rules) map { case(key, value) =>
        var v = value
        if(key.endsWith("/ReverseRoutes.scala")) {
          v = v.replace("import ReverseRouteContext.empty", "implicit val empty = ReverseRouteContext(Map())")
          v = v.replace("import play.core.routing.{ HandlerDef, ReverseRouteContext, queryString, dynamicString }", "import play.core.routing.{ ReverseRouteContext, queryString }")
          v = v.replace("import play.api.mvc.{ QueryStringBindable, PathBindable, Call, JavascriptLiteral }", "import play.api.mvc.{ QueryStringBindable, Call }")
        }
        if(key.endsWith("migrations/ReverseRoutes.scala")) {
          v = v.replace("import play.api.mvc.{ QueryStringBindable, Call }", "import play.api.mvc.{ Call }")
          v = v.replace("import play.core.routing.{ ReverseRouteContext, queryString }", "import play.core.routing.{ ReverseRouteContext }")
        }
        if(key.endsWith("/JavaScriptReverseRoutes.scala")) {
          v = v.replace("import ReverseRouteContext.empty", "")
          v = v.replace("import play.api.mvc.{ QueryStringBindable, PathBindable, Call, JavascriptLiteral }", "import play.api.mvc.{ QueryStringBindable, JavascriptLiteral }")
          v = v.replace("import play.core.routing.{ HandlerDef, ReverseRouteContext, queryString, dynamicString }", "")
        }
        if(key.endsWith("migrations/javascript/JavaScriptReverseRoutes.scala")) {
          v = v.replace("import play.api.mvc.{ QueryStringBindable, JavascriptLiteral }", "")
        }
        if(key.endsWith("/Routes.scala")) {
          v = v.replace("import play.core.routing.HandlerInvokerFactory._", "")
          v = v.replace("import play.core.j._", "")
          v = v.replace("import ReverseRouteContext.empty", "implicit val empty = ReverseRouteContext(Map())")
        }
        (key, v)
      }
    }

    def id: String = "injected+"
  }
}

El complemento Play sbt genera código de rutas (se puede ver en target/scala-2.11/routes ). Este fragmento de código elimina o inserta todas las importaciones no utilizadas. Es posible que tenga que adaptarlo para sus rutas.

Answer 3

Una "solución" horrible podría ser eliminar aquellas importaciones no utilizadas después de que se generen las rutas pero antes de que se ejecute la tarea de compilación. Aquí hay un bosquejo:

lazy val optimizeRoutesImports = taskKey[Unit]("Remove unused imports from generated routes sources.")

optimizeRoutesImports := {

  def removeUnusedImports(targetFiles: (File) => PathFinder, linesToRemove: Set[String], linesToReplace: Map[String, String]) = {
    val files = targetFiles(crossTarget.value).get
    files foreach { file =>
      val lines = sbt.IO.readLines(file)
      val updatedLines = lines map { line =>
        linesToReplace.getOrElse(line, line)
      } filterNot { line =>
        linesToRemove.contains(line.trim)
      }
      sbt.IO.writeLines(file, updatedLines, append = false)
    }
  }

  removeUnusedImports(
    _ / "routes" / "main" / "controllers" / "ReverseRoutes.scala",
    Set("import ReverseRouteContext.empty"),
    Map(
      "import play.api.mvc.{ QueryStringBindable, PathBindable, Call, JavascriptLiteral }" ->
        "import play.api.mvc.{ QueryStringBindable, PathBindable, Call }",
      "import play.core.routing.{ HandlerDef, ReverseRouteContext, queryString, dynamicString }" ->
        "import play.core.routing.{ ReverseRouteContext, queryString, dynamicString }"
    )
  )

  removeUnusedImports(
    _ / "routes" / "main" / "controllers" / "javascript" / "JavaScriptReverseRoutes.scala",
    Set(
      "import play.core.routing.{ HandlerDef, ReverseRouteContext, queryString, dynamicString }",
      "import ReverseRouteContext.empty"
    ),
    Map(
      "import play.api.mvc.{ QueryStringBindable, PathBindable, Call, JavascriptLiteral }" ->
        "import play.api.mvc.{ QueryStringBindable, PathBindable }"
    )
  )

  removeUnusedImports(
    _ / "routes" / "main" / "router" / "Routes.scala",
    Set("import play.core.j._"),
    Map())
}

A continuación, querrá ordenar las dependencias de tareas:

// Our optimize routes imports task depends on the routes task.
optimizeRoutesImports := (optimizeRoutesImports dependsOn (play.sbt.routes.RoutesKeys.routes in Compile)).value

// And compilation depends on the unused routes having been removed.
compile := ((compile in Compile) dependsOn optimizeRoutesImports).value

También es probable que necesites configurar TwirlKeys.templateImports en una lista conservadora antes de habilitar -Ywarn-unused-import . Algo como esto, dependiendo de qué tipos se utilizan en sus vistas:

TwirlKeys.templateImports := Seq("play.api.mvc._", "play.api.i18n.Messages", "controllers.routes")

También tuve que eliminar las importaciones de TemplateMagic sin usar de las TemplateMagic Twirl (YMMV):

  removeUnusedImports(
    _ / "twirl" ** "*.template.scala",
    Set("import play.twirl.api.TemplateMagic._"),
    Map())

Si lo hace, asegúrese de que las dependencias de la tarea estén configuradas adecuadamente.

Esto funciona para mí. Scala 2.11.8, Play 2.5.10, ambos -Xfatal-warnings y -Ywarn-unused-import habilitados. Es horrible, pero funciona.