Sbt plugin for jruby - maven-2

Question

Is there a plugin for sbt available which automatically installs JRuby and adds some hooks to automatically run scripts at certain points (e.g. before compilation).
Background: For a (lift) project, I want to use sass, or more specifically, compass as a tool for generating the css. A Java or Scala clone of sass would not be enough, unfortunately.
Of course, It wouldn’t be a problem at all to just generate the css manually and then put both inside the repository and no-one ever needs to care about it.
On the other hand, to ease development on several systems, I’d rather have a clear dependency inside sbt which simply does the work.
Is there any way to achieve this?
Or generally: Is there a way to run JRuby scripts from inside Scala?
Edit Added maven-2 to the tags. Maybe there is a maven repo for JRuby which allows me to deliver and use it somehow.

Answer 1

While it's perhaps not the most elegant solution, you can always call external scripts using the Process support in SBT.
import sbt._
import Process._
class Project(info: ProjectInfo) extends DefaultProject(info) {
lazy val runSomething = task {
"ruby somescript.rb" ! log
None
}
}
There's a bit more info about the external process support available here: http://code.google.com/p/simple-build-tool/wiki/Process

Answer 2

Try my sbt plugin from github. It's very bare-bones for now, but it should download the jruby jar and allow you to call a .rb file before compiling.
The guts of the plugin are really simple:
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])
}
}
Really all it's doing is calling the jruby jar file with the name of the rb file you've passed in. And of course adding jruby itself as a managed dependency:
libraryDependencies ++= Seq(
"org.jruby" % "jruby-complete" % "1.6.5"
)
It also adds a "jirb" command to the Scala console that puts you into a jirb session.