plug-in pour SBT JRuby

Question

Y at-il un plugin pour SBT disponible qui installe automatiquement JRuby et ajoute quelques crochets pour exécuter des scripts automatiquement à certains points (par exemple avant la compilation).

Arrière-plan: Pour un (ascenseur) projet, je veux utiliser SASS , ou plus précisément, boussole comme un outil pour générer le CSS. Un Java ou clone Scala de SASS ne serait pas suffisant, malheureusement.

Bien sûr, il ne serait pas un problème du tout juste générer le css manuellement, puis mis à la fois à l'intérieur du dépôt et personne ne doit jamais se soucier à ce sujet.

D'autre part, pour faciliter le développement sur plusieurs systèmes, je préfère avoir une dépendance claire à l'intérieur SBT qui fait simplement le travail.

Y at-il moyen d'y parvenir?
Ou généralement: Est-il possible d'exécuter des scripts JRuby de l'intérieur Scala

?

Modifier Ajouté maven-2 aux tags. Peut-être il y a une prise en pension de Maven pour JRuby qui me permet de livrer et de l'utiliser en quelque sorte.

Answer 1

Bien qu'il soit peut-être pas la solution la plus élégante, vous pouvez toujours appeler des scripts externes en utilisant le support de processus dans la société SBT.

import sbt._
import Process._

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

Il y a un peu plus d'informations sur le support de processus externe disponible ici: http : //code.google.com/p/simple-build-tool/wiki/Process

Answer 2

Essayez mon plug-in SBT de GitHub. Il est très os à nu pour l'instant, mais il faut télécharger le pot de JRuby et vous permettre d'appeler un fichier .rb avant de compiler.

Les entrailles du plug-in sont très 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])
      }
    }

vraiment tout ce qu'il est fait est d'appeler le fichier jar de JRuby avec le nom du fichier rb que vous avez passé dans Et bien sûr ajouter JRuby lui-même comme une dépendance gérée.

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

Il ajoute également une commande "jirb" à la console Scala qui vous met dans une session de jirb.