Plugin de SBT para jruby

Question

¿Hay un plugin para SBT disponible que instala automáticamente JRuby y añade algunos ganchos para ejecutar scripts de forma automática en ciertos puntos (por ejemplo, antes de la compilación).

Antecedentes: Para un proyecto (ascensor), quiero usar Sass , o más específicamente, brújula como una herramienta para la generación de la CSS. Un clon de Java o Scala de Sass no sería suficiente, por desgracia.

Por supuesto, no sería un problema en absoluto a poco generar el CSS de forma manual y luego poner tanto en el interior del depósito y nadie nunca tiene que preocuparse por ello.

Por otra parte, para facilitar el desarrollo de varios sistemas, prefiero tener una dependencia clara dentro de SBT, que simplemente hace el trabajo.

¿Hay alguna manera de lograr esto?
O en general: ¿Hay una manera de ejecutar scripts JRuby desde el interior Scala

?

Editar añadió maven-2 a las etiquetas. Tal vez hay un acuerdo de recompra experto para JRuby que me permite disposición y utilización de alguna manera.

Answer 1

Si bien no es quizá la solución más elegante, siempre puede llamar a scripts externos utilizando el soporte de procesos en SBT.

import sbt._
import Process._

class Project(info: ProjectInfo) extends DefaultProject(info) {
  lazy val runSomething = task {
    "ruby somescript.rb" ! log
    None
  }
}

Hay una información poco más sobre el soporte de procesos externo disponible aquí: http : //code.google.com/p/simple-build-tool/wiki/Process

Answer 2

Trate de mi SBT complemento de GitHub. Es muy escueto por ahora, pero debe descargar el frasco jruby y permitirá llamar a un archivo .rb antes de compilar.

Las tripas del plug-in son muy simples:

    import sbt._

    object SbtJRuby extends Plugin {
      object SbtJRubySettings {
        lazy val settings = Seq(Keys.commands += jirb, tx, jrubyFile := file("fnord.rb"))
      }

      def jirb = Command.args("jirb", "<launch jirb>") { (state, args) =>
        org.jruby.Main.main(List("-S", "jirb").toArray[String])
        state
      }

      val jruby = TaskKey[Unit]("jruby", "run a jruby file")
      val jrubyFile = SettingKey[File]("jruby-file", "path to file to run with JRuby")

      val tx = jruby <<= (jrubyFile, Keys.baseDirectory) map { (f: File, b: File) =>
        val rb = (b / f.toString).toString
        //    println("jruby with " + rb)
        org.jruby.Main.main(List(rb).toArray[String])
      }
    }

Realmente todo lo que está haciendo está llamando el archivo jar jruby con el nombre del archivo rb que haya pasado en Y, por supuesto añadiendo jruby a sí misma como una dependencia administrado:.

libraryDependencies ++= Seq(
  "org.jruby" % "jruby-complete" % "1.6.5"
)

También agrega un comando "jirb" a la consola Scala que le pone en una sesión jirb.