Play! est un framework web pour Java avec le vent en poupe. Il est constitué d’une stack complète, pas besoin de conteneur de servlet ni de serveur d’application. C’est léger, rapide, stateless et ca s’inspire très fortement de Rails. On y trouve tout ce dont on a besoin pour développer des applications web : système de templating, ORM (Hibernate), cache, un système de plugin et une communauté fleurissante. Le système de template du module Scala est plutôt cool : un template est une fonction à laquelle on passe des paramètres qui retourne du Html. Nos templates s’imbriquent les uns dans les autres via des appels de fonctions : avec la compilation et typage statique c’est puissant !

J’ai suivi le tutoriel de James Ward pour le setup du projet dans IntelliJ (on peut développer avec un editeur de texte, mais à mon gout ca ne remplace pas un puissant IDE).

L’exposition de services RESTFull est triviale avec Play!. Le client HTML5 + Js avec JQuery fait ses appels asynchrones et consomme les services en question. Rapidement, le besoin d’une solution pour serializer des graphes d’objets au format Json s’est fait sentir.  Après quelques tests je suis tombé sur le JsonDSL de lift-json pour faire du Json en Scala.

La dépendance à ajouter dans votre dependencies.yml est la suivante :

require :
    - ...
    - net.liftweb -> lift-json_2.8.1 2.2

Voici un exemple de serialization d’une instance de Graphe :

def toJson: JObject = {
    import net.liftweb.json.JsonDSL._
    ("nodes", nodeToPosition.toList.map { n =>
        (("label", n._1.name) ~ ("x", n._2.apply(0)) ~ ("y", n._2.apply(1)) ~ ("weight", n._1.weight) ~ ("anchor",n._1.isFixed))
    }) ~ ("edges", edges.map { e =>
        (("source", e.startNode.name) ~ ("target", e.endNode.name) ~ ("length", e.weight))
    })
}

L’opérateur "~" , équivalent sémantique de la méthode ".~()" permet de construire très simplement la structure de son objet Json.
Ensuite dans le controller on retourne le resultat comme suit :

package controllers

import play.mvc._
import net.liftweb.json.JsonAST
import net.liftweb.json.Printer._
import models.ForceDirectedLayout

object Graphs extends Controller {

    def show(id:String, w:Int = 860, h:Int = 600) = {
        val layout = new ForceDirectedLayout(id).execute(100).scale(w,h)
        Json(compact(JsonAST.render(layout.toJson)))
    }
}

Ce qui produit des documents Json de cette forme ci :

Si vous avez connaissance d’une meilleure technique je suis preneur, avec Jackson ou Gson par exemple.

Pour terminer je voulais pousser la webapp sur Heroku (suite à leur annonce réjouissante) en suivant le tuto de James Ward toujours.
Un petit git push heroku master mais je reste bloqué sur le message suivant :

Counting objects: 154, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (143/143), done.
Connection to 10.86.82.54 closed by remote host.KiB/s
error: pack-objects died of signal 13
error: failed to push some refs to 'git@heroku.com:taraxe.git'

A suivre donc…

A venir dans un prochain billet, je ferai une revue de la nouvelle édition du livre Apache Maven 2 et 3 de Nicolas De Loof et Arnaud Héritier.

Comme disait un ancien collègue : "quand il n’y a pas de code, il n’y a pas de bug". Avec Scala justement, on écrit bien moins de code qu’en Java, et donc j’imagine moins de bugs. Quelques rapides exemples pour illustrer le propos d’un développeur Java charmé par ce langage :

Concision

Voici comment déclarer une classe avec deux attributs immutables et des contraintes sur ceux ci :

class GrassField(val width: Int, val height: Int) {
    require(width > 0 && height > 0, "Width and Height must be postive integers")
    override def toString = "Field(" + width + "," + height + ")";
}

Lire la première ligne d’un fichier, extraire deux entiers puis itérer sur le reste 2 lignes par 2 lignes :

val lines = Source.fromFile(file).getLines().toTraversable
val fieldDimensions = lines.head.split(' ') map (_.toInt)
val field = new GrassField(fieldDimensions(0),fieldDimensions(1))
lines.tail.toIterator.sliding(2, 2).foreach {...}

Pattern Matching

Processing d’une chaine de caractère lettre par lettre :

seq.toCharArray.foreach {
_ match {
    case 'A' => {...}
    case 'G' => {...}
    case 'D' => {...}
    case _ => throw new IllegalArgumentException("Invalid instruction, must be either 'A', 'G', 'D'")
}

Acteurs

Pour parallèliser l’éxécution d’une méthode sur chacun des éléments d’une liste :

val caller = self
listToProcess foreach (i => {
    actor {
        caller ! longComputationMethod(i)
    }
})
val results = ("" /: (0 until listToProcess.length)) { (partialResult, i) =>
    receive {
        case r:String => {
            partialResult + ", " + i
        }
    }
}

Conclusion

Ca fait drôle au début mais plus on code avec Scala plus on a envie de coder  : au début c’est un peu difficile, mais après cela s’avère être un bon stimulant neuronal. Ce très rapide billet est un aperçu des fonctionnalités du langage. Je reviendrai dessus à mesure que je descendrai dans du code plus élaboré dans un prochain article. En attendant je vous conseille l’excellent PDF ‘Scala For the Impatient‘ de Cay Horstmann distribué gracieusement par TypeSafe.

Génération du plugin

Avec le SDK d’Atlassian correctement installé et configuré, utilisez la commande atlas-create-confluence-plugin pour créer un plugin, nommez le groupId, l’artifactId et le packageName comme bon vous semble.

Dans la structure du projet, à code des dossiers src/main et src/test, créer un dossier "scala" à coté de celui nommé "java". Vous vous en doutez, c’est là que nous mettrons nos fichiers sources Scala.

Vous devriez avoir une structure de ce format :

Modification du pom.xml

Il s’agit ici d’intégrer la dépendance vers la bibliothèque Scala et le plugin maven-scala-plugin à notre descripteur de projet Maven.

Dans les dépendances, ajoutez l’artifact scala-library :

<dependency>
    <groupId>org.scala-lang</groupId>
    <artifactId>scala-library</artifactId>
    <version>${scala.version}</version>
</dependency>

Entre les balises <plugins></plugins>, ajouter le plugin maven-scala-plugin :

<plugin>
    <groupId>org.scala-tools</groupId>
    <artifactId>maven-scala-plugin</artifactId>
    <executions>
        <execution>
            <goals>
                <goal>compile</goal>
                <goal>testCompile</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <scalaVersion>${scala.version}</scalaVersion>
    </configuration>
</plugin>

Dans les balises <properties></properties> ajouter la propriété scala.version :

<scala.version>2.9.0</scala.version>

Ajoutez aussi les repository maven qui distribuent les artifacts nécessaires :

<repositories>
    <repository>
        <id>scala-tools.org</id>
        <name>Scala-Tools Maven2 Repository</name>
        <url>http://scala-tools.org/repo-releases</url>
    </repository>
</repositories>

<pluginRepositories>
    <pluginRepository>
        <id>scala-tools.org</id>
        <name>Scala-Tools Maven2 Repository</name>
        <url>http://scala-tools.org/repo-releases</url>
    </pluginRepository>
</pluginRepositories>

Traduction

Créer un fichier ExampleMacro.scala dans le dossier src/main/scala. Voici la version scala de la macro ExampleMacro.java générée en example par le SDK :

N’oubliez pas d’effacer la version Java ( src/main/java/ExampleMacro )

Test

Dans un terminal avec le répertoire courant dans le dossier du projet, faites mvn confluence:run.
Rendez vous dans votre navigateur web sur à l’URL suivante http://localhost:1990/confluence
Logger vous en admin/admin, puis sur le dashboard, allez dans l’espace de démonstration et éditer sa home page : y ajouter la macro sample-plugin-with-scala et valider.

Tada!

Conclusion

Nous avons vu aujourd’hui la simplicité déconcertante d’ajouter Scala à notre outillage de développement de plugin pour Confluence. L’interopérabilité Java/Scala semble bonne (la compilation génère le même bytecode, à l’exception de l’utilisation de certaines fonctionnalités propres à Scala). Vous n’avez plus d’excuse pour tout en développant des plugins Confluence monter en compétence sur Scala (et devenir un polyglot programmer!).

Les sources sont disponibles sur BitBucket.