A ma grande déception zsh ne complète pas la commande maven. A force de taper des commandes mvn qqhcose, j’en avais assez, j’ai donc fait un petit script pour compléter les commandes que j’utilise le plus souvent avec maven et le plugin Scala :

function mainClasses {
    if [ -d ./src ] ; then
	find ./src/main -type f -iname "*.scala"  -o -iname "*.java" \
             | sed 's?.*src/main/[^/]*/\(.*\)\..*?-DmainClass=\1?' | sed 's+/+.+g'
    fi
}
 
function mainTests {
    if [ -d ./src ] ; then
	find ./src/test -type f -iname "*test*.scala"  -o -iname "*test*.java"  \
             | sed 's?.*src/test/[^/]*/\(.*\)\..*?-Dtest=\1?' | sed 's+/+.+g'
    fi
}
 
function listMavenCompletions {
reply=(archetype:generate compile clean package install test
    test-compile deploy release scala:run scala:cc
    -Dmaven.test.skip=true
    -DarchetypeCatalog=http://www.scala-tools.org/
    `mainClasses`
    `mainTests`
    -q -o
    );
 
}
 
compctl -K listMavenCompletions mvn%

Le script n’est pas idéal mais il permet de compléter les commandes que j’utilise le plus souvent mais aussi les -Dtest= et -DmainClass= automatiquement en listant les fichiers de l’arborescence de votre projet. L’ideal serait d’avoir une option dans maven pour lister les commandes disponibles, mais ça n’existe pas à ma connaissance.

Si vous utilisez d’autres commandes maven, ajouter les dans la liste reply (séparer par des espaces ou saut de lignes).

Vous pouvez copier ce script dans votre ~/.zshrc.

Introduction

Dans un précédent article, nous vous présentions sbt. Cette fois nous allons voir comment gérer un projet Scala avec maven.

Le plus simple, c’est de démarrer de zéro, et d’initialiser un projet en utilisant un archetype prédéfini. Cet archetype est un template de projet qui contient le minimum pour démarrer :

• La structure de répertoire de projet
• Le pom.xml
• Des fichiers sources quasiment vide (un main(), et un test pour scala-archetype-simple)

Initialisation d’un projet

Pour l’initialisation d’un projet nous allons utiliser le plugin maven archetype (disponible dans le repository officiel de maven). Nous allons passer en paramètre de ce plugin, un lien vers une liste d’archetype : scala-tools (pour le moment, seul site à proposer des archetypes pour Scala).

$ mvn archetype:generate -DarchetypeCatalog=http://scala-tools.org
    [...]
    Choose archetype:
    1: http://scala-tools.org -> scala-archetype-simple (A simple scala project)
    2: http://scala-tools.org -> lift-archetype-blank (A blank/empty liftweb project)
    3: http://scala-tools.org -> lift-archetype-basic (A basic liftweb project (with DB, css, ...))
    Choose a number:  (1/2/3): 1

Le plugin va ensuite vous posez quelques questions pour générer le pom.xml. Sélectionner le projet scala de base (1) à moins que vous soihaitiez faire du lift.

Le projet ainsi initialisé contient déjà quelques dépendances et quelques plugins pratiques pour une bonne gestion d’un projet Scala :

• Un lien vers le repository maven de bibliothèques et de plugins Scala-tools: http://scala-tools.org/repo-releases
• Une dépendance vers jUnit
• Une dépendance vers specs
• Le plugin maven-scala-plugin

Quelques actions de maven-scala-plugin

Les goal maven classiques sont biensûr fonctionnels (compile, package, release, …).

Le goal scala, propose différentes actions notamment :

• Lancer une application

  $ mvn scala:run -DmainClass=org.example.MyClass
  

• Générer la documentation de l’API

  $ mvn scala:doc
  

• Lancer le mode compilation continue (lance une boucle infinie qui compile toutes les sources qui sont sauvegardées, très pratique si vous développez avec un éditeur de texte simple type emacs ou vi)

  $ mvn scala:cc
  

Note pour les utilisateurs d’emacs : vous pouvez passer en compilation-mode avec cette astuce pour lancer maven, puis lancer mvn scala:cc, je vous conseil aussi d’ajouter cette ligne dans votre .emacs.el : (setq compilation-scroll-output t) pour enclencher le scrolling automatique de la fenetre de compilation. Avec ça (et les ctags pour la complétion), vous pouvez jeter Eclipse et NetBeans . Vous pouvez aussi utiliser le flymake-mode beaucoup plus pratique mais malheuresement un peu lent à cause de l’utilisation de maven en arrière plan.

Je n’ai rien contre Eclipse ou Netbeans, mais mon process emacs ne dépasse jamais 30Mo de RAM et il ne s’arrête pas inopinément.

Plus de détails sur la page de documentation de maven-scala-plugin.

Ajouter des dépendances

C’est du maven classique. Pour ajouter une dépendance, éditer votre fichier pom.xml et ajouter les groupId / artifactId / version dont vous avez besoin dans project->dependencies. Si je veux par exemple ajouter la dépendance vers scalacheck, il me suffit d’ajouter :

<dependencies> 
[...] 
  <dependency> 
    <groupid>org.scala-tools.testing</groupid> 
    <artifactid>scalacheck</artifactid>
    <version>1.5</version>
  </dependency>
[...]
</dependencies>

Note : ScalaCheck est disponible sur le repository maven scala-tools (ajouté par défaut à l’initiation du projet avec l’archetype scala-archetype-simple).

Démonstration

Une démonstration de l’utilisation de mvn dans emacs, en utilisant mvn archetype:generate pour initialiser un projet exemple.

Introduction

sbt signifie Scala Build Tool. Encore un outils de compilation ? ant, maven ne suffisent pas ?

sbt se veut non intrusif : vous pouvez l’utiliser sans modifier la disposition de votre projet, uniquement en modifiant un descripteur (ce descripteur est écrit en Scala, un peu comme scons pour Python ou rake en Ruby). Pour cela il se base sur le même format de projet que maven.

src/
  main/
    resources/  # Fichiers à inclure dans le jar principal
    scala/      # Sources Scala
    java/       # Sources Java
  test/
    resources   # Fichiers à inclire dans le jar de test
    scala/      # Sources de Test Scala
    java/       # Sources de Test Java

Son principal intérêt est d’intégrer des outils liés à Scala sans avoir besoin de configurer quoique ce soit:

• Génération de documentation avec scaladoc.
• Tests unitaires avec ScalaTest.
• Génération de tests unitaires avec ScalaCheck.
• Intégration de specs, framework de behavior driven development.

sbt se base sur maven par défaut pour gérer les dépendances.

Installer sbt

Malheuresement sbt n’est pas packagé dans sbaz. Il vous faudra le télécharger et l’installer à la main.

Pour cela, rien de plus simple, télécharger la dernière version de sbt-launcher.jar sur la page de téléchargement de sbt.

Puis créer un script shell dans votre PATH, chez moi ça donne ça :

$ echo $PATH
/sw/bin:/sw/sbin:/Users/max/dist/sbin
$ wget http://simple-build-tool.googlecode.com/files/sbt-launcher-0.5.4.jar -O /Users/max/dist/sbin/sbt-launcher.jar
$ echo 'java -Xmx512M -jar `dirname $0`/sbt-launcher.jar "$@"' > /Users/max/dist/sbin/sbt
$ chmod +x /Users/max/dist/sbin/sbt

sbt est installé, vous pouvez le l’utiliser.

Utiliser sbt

sbt se lance en mode interactif ou en mode batch. Le mode batch permet de lancer une suite de tâches les unes à la suite des autres. Le mode interactif lance un shell particulier vous permettant de taper des commandes particulières (tâches ou autres).

Lorsque vous lancer sbt dans un répertoire qui ne contient pas les descripteurs, il va vous proposer de créer une structure de projet.

Créer un projet

Lancer sbt sans arguments dans le répertoire où vous souhaitez créer votre projet:

$ mkdir sbttest
$ sbt
Project does not exist, create new project? (y/N/s) : y
Name: SbtTest
Organization []: scala-fr
Version [1.0]: 
Scala version [2.7.5]: 
sbt version [0.5.3]: 
[...]
[success] Successfully initialized directory structure.

Voilà, la structure de projet est créée, voici à quoi elle ressemble :

$ \tree
|-- lib
|-- project
|   |-- boot
|   |   `-- scala-2.7.5
|   |       |-- lib
|   |       |   |-- scala-compiler.jar
|   |       |   `-- scala-library.jar
|   |       |-- sbt-0.5.3
|   |       |   |-- ivy-2.0.0.jar
|   |       |   |-- jsch-0.1.31.jar
|   |       |   `-- sbt_2.7.5-0.5.3.jar
|   |       `-- update.log
|   `-- build.properties
|-- src
|   |-- main
|   |   |-- resources
|   |   `-- scala
|   `-- test
|       |-- resources
|       `-- scala
`-- target

Mode interactif

Si vous le lancer sans arguments dans un répertoire projet, il démarre en mode interactif:

$ sbt
[info] Building project xxx 0.1 using XXX
[info]    with sbt 0.4.6 and Scala 2.7.4
[info] No actions specified, interactive session started. Execute 'help' for more information.
>

Un shell sbt est ouvert, vous pouvez tapez vos commandes.

Mode batch

En mode batch vous lancer directement les tâches (Consulter la liste exhaustive des tâches)

Exemple, je viens d’écrire du code (un simple println("hey !")dans le fichier src/main/scala/sbttest.scala, je lance la tâche run:

$ sbt run
[info] Building project SbtTest 1.0 using sbt.DefaultProject
[info]    with sbt 0.5.3 and Scala 2.7.5
...
[info] == compile ==
...
[info] == run ==
[info] Running RunSbtTest ...
hey !
...
[info] Total build time: 1 s

On s’aperçoit que la tâche run dépend de la tâche compile, et ça tombe bien . Vous venez de compiler et de lancer votre premier projet Scala avec sbt et son projet par défaut (sbt.DefaultProject).

Conclusion

Ca sera tout pour cet article, il y a pas mal de possibilités qui n’ont pas été abordées ici. Elles le seront sûrement un peu plus en détails dans les futurs articles.

En apparence sbt simplifie tout. Pour les projets Scala simple, il sera sûrement parfaitement adapté, mais dès que vous commencez à dévier du chemin classique, ça devient plus complexe et mal documenté; c’est là que les ennuis commencent.

Même si vous avez l’habitude, et préférez utiliser maven; si vous êtes développeur Scala, vous aurez sûrement besoin d’installer sbt pour compiler des projets tiers. Ce sera une bonne occasion pour apprendre quelques commandes, le tester et vous en faire votre opinion.

En savoir plus:

• Différents modes d’installation : How to setup sbt
• Utilisation : Basic usage
• Aller plus loin dans la mise en place de vos propre option de build: Build Configuration