Plugin Sbt para jruby

Question

Hay un plugin para sbt disponible que instala JRuby automáticamente y agrega algunos ganchos para ejecutar scripts automáticamente en ciertos puntos (por ejemplo, antes de la compilación).

Antecedentes: Para un proyecto (de elevación), quiero usar sass, o más específicamente, compass como herramienta para generar el CSS. Un clon de sass de Java o Scala no sería suficiente, desafortunadamente.

Por supuesto, no sería un problema en absoluto simplemente generar el CSS manualmente y luego poner ambos dentro del repositorio y nadie nunca tiene que preocuparse por ello.

Por otro lado, para facilitar el desarrollo en varios sistemas, prefiero tener una clara dependencia dentro de sbt que simplemente hace el trabajo.

¿Hay alguna manera de lograr esto?
O en general: ¿hay alguna forma de ejecutar scripts JRuby desde dentro de Scala?

Editar Se agregó maven-2 a las etiquetas. Tal vez haya un repositorio maven para JRuby que me permita entregarlo y usarlo de alguna manera.

Answer 1

Aunque quizás no sea la solución más elegante, siempre puede llamar a scripts externos utilizando el soporte de Proceso en SBT.

import sbt._ 
import Process._ 

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

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

Answer 2

intentar mi sbt plugin de GitHub. Es muy básico por ahora, pero debería descargar el jruby jar y permitirte 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, la adición de jruby 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.