Etant donné que je ne suis pas homme à gueuler sans preuve, voici la démonstration de ce que j’avance.

Je vous laisse le temps de lire ce petit bout de code et deviner le résultat logique d’une exécution…
Si vous pensez comme moi, vous vous attendez à ce résultat:

Object: java.lang.String

Integer

Float

Réfléchissons deux minutes.

Nous avons une liste qui contient différents objets, une chaîne de caractère, un entier et un nombre décimal. Notre classe Main présente une méthode polymorphique prenant en paramètre un Object, un Integer ou un Float.
Pour le premier objet la méthode la plus approchante est la méthode avec le paramètre Object.
Pour les deux autres la méthode avec le paramètre de type exact va être appelé du fait que la liaison en java est dynamique et décidée à l’exécution. Le fameux « VIRTUAL » des programmeurs C++.

Voyons le résultat de l’exécution (JVM 1.6 sur MacOS 10.6 dit « Snow Leopard »):

Object: java.lang.String
Object: java.lang.Integer
Object: java.lang.Float

Mais ????!!!! Voilà un résultat qui ferait lacher à nos amis anglo-saxons un virulent « WTF ?! ». Que c’est-il passé ?

Et bien c’est extrêmement facile. Nous nous trouvons devant un manique échec de Java et ses méthodes liées à l’exécution… Le compilateur voit que l’ArrayList contient des instances de Object, il voit une méthode prenant en paramètre un Object, il fait la liaison à la compilation. Dans le langage courant on dirait simplement: JAVA FAIL !

Si vous ne me croyez pas, vous pouvez simplement télécharger le fichier de test ici (en renommant le fichier Main.java évidemment). Pour le principe j’ai changé Object en Number (superclasse de Integer, Float, Double, …) et le résultat est bien sûr le même, comme vous le constaterez là.

Voici une liste de ces composants avec leur syntaxe à l’ancienne, la nouvelle syntaxe et quelques exemples d’utilisation.

Comme d’habitude vous pouvez opter pour la version PDF du tutoriel.

WOString

Rôle

C’est probablement le composant le plus utilisé du framework. Son but est simple, afficher une chaîne de caractère. Vous pouvez l’inclure un peu où vous voulez pour y insérer une chaîne de caractère.

Bindings importants

value: chaîne de caractère que vous souhaitez afficher, tout simplement.
numberFormatter: instance de NSNumberFormatter à utiliser s’il s’agit d’une valeur numérique qu’il faudra parser et/ou formatter.
dateFormatter: chaîne de caractère pour indiquer les informations l’affichage d’une valeur de type date.

Inline tags

<wo:str />
<wo:string>

WOConditionnal

Rôle

Permet d’afficher un bloc selon une condition, par exemple « Afficher ce bloc si l’utilisateur connecté est administrateur ».

Bindings importants

condition: condition à laquelle le code contenu sera affiché. Quelque soit le type de paramètre passé, un cast vers boolean est effectué. Comprenez que false, null, chaîne vide et 0 (zéro) valent FAUX. N’importe quoi d’autre est vrai.
negate: si ce binding est mis à vrai, c’est la négation de la condition qui déclanchera l’affichage du code. Par défaut ce binding est à faux.

Inline tags

<wo:if> … </wo:if>
<wo:conditionnal> … </wo:conditionnal>
<wo:condition> … </wo:condition>

Notez qu’en utilisant ces tags inline vous disposez d’un petit raccourci avec un tag ayant pour sa part negate par défaut à vrai comme son nom l’indique.

<wo:not> … </wo:not>

WORepetition

Rôle

En complément des trois éléments précédents, vous avez avec celui-ci de quoi faire les trois quarts de vos applications. L’élément WORepetition permet de parcourir une liste ou de faire un certain nombre d’itérations. C’est le composant dont le fonctionnement demande le plus d’explication sur son fonctionnement.

Admettons que vous utilisiez le WORepetition avec une liste d’éléments de type User. Vous allez alors mettre en place un binding sur item de type User appelé « currentUser », accessible en lecture et en écriture. À chaque tour de boucle, le setter de ce binding sera appelé afin d’y placer la valeur courante. Ainsi lorsque vous allez vouloir afficher par exemple le nom de votre utilisateur courant, vous utiliserez simplement un binding currentUser.name, donc inutile de vous prendre la tête avec des indices de liste quand vous codez le contenu du composant.

Bindings importants

list: si vous souhaitez itérer sur les composants d’une liste, c’est ici que vous devrez fournir la liste.
item: élément courant pendant l’execution de la boucle.
count: il s’agit d’une alternative à list, permettant d’itérer un nombre de fois précis sans se référer au parcours d’une liste.
index: binding lecture/écriture qui contiendra la valeur i pour la ième itération.

Inline tags

<wo:foreach> … </wo:foreach>
<wo:repeat> … </wo:repeat>
<wo:repetition> … </wo:repetition>
<wo:loop> … </wo:loop>

AjaxUpdateContainer

Rôle

Par la suite, je vais parler de composants Ajax, il m’est donc obligatoire de parler de l’AjaxUpdateContainer. Son principe est très simple, le composant sera par la suite transformé en une zone <div> munie d’un id que vous lui aurez fourni. Vous pouvez alors ajouter à votre page des composants Ajax qui vont déclencher une action sur le serveur, et indiquer l’id de votre AjaxUpdateContainer de façon à ce que le résultat de votre action vienne remplacer son contenu actuel.

Si vous aviez besoin de mettre à jour plusieurs panneaux de votre écran sur une seule action du serveur, regardez AjaxUpdateTrigger

Bindings importants

id: chaîne de caractère qui permet d’identifier votre élément de manière unique dans une page.

Inline tags

<wo:AjaxUpdateContainer> … </wo:AjaxUpdateContainer>

WOHyperlink / AjaxHyperlink

Rôle

Inutile de vous faire un dessin. Il s’agit de liens classiques et ajax.

Bindings importants

action: il est vivement recommandé d’utiliser ce bindings plutôt que href ou pageName car il est plus facile de détecter une erreur dans un fichier Java que dans un fichier HTML.
directActionName: pour appeler une directAction plutôt qu’une action du composant sous-jacent.
string: chaîne de caractère à afficher pour représenter le lien (vous pouvez aussi l’insérer dans les balises)
updateContainerID: pour AjaxHyperlink, partie de la page à rafraichir avec le composant renvoyé par l’action appelée.

Inline tags

Pour le WOHyperlink

<wo:link> … </wo:link>
<wo:hyperlink> … </wo:hyperlink>

Le AjaxHyperlink n’a par défaut pas de raccourci.

<wo:AjaxHyperlink> … </AjaxHyperlink>

WOSubmitButton / AjaxSubmitButton

Rôle

Vous aurez compris que vous avec affaire aux éléments qui vont générer un input de type submit. Ces deux composants doivent se trouver dans un formulaire (créé de préférence à l’aide d’un WOForm, aucun binding important).

Bindings importants

action: le fonctionnement est le même que pour le WOHyperlink à ceci près que les données contenues dans le formulaire contenant le bouton vont être envoyées au serveur, ce qui n’est pas le cas avec le WOHyperlink (ni avec le AjaxUpdateLink).
value: chaîne de caractère à afficher sur le bouton.
updateContainerID: pour AjaxSubmitButton, partie de la page à rafraichir avec le composant renvoyé par l’action appelée.

Inline tags

Pour le WOSubmitButton

<wo:submit> … </wo:submit>
<wo:submitButton> … </wo:submitButton>

Pour le AjaxSubmitButton

<wo:AjaxSubmitButton> … </wo:AjaxSubmitButton>

ERXElse

Rôle

Pas un essentiel du tout mais un apport particulièrement appréciable de Wonder. Souvent lors de l’usage d’un WOConditionnal, on a également un comportement à définir pour le cas où la condition n’est pas satisfaite. C’est une partie de l’origine du binding negate, puisqu’au lieu d’écrire deux conditions, il suffisait d’utiliser deux fois la même et d’utiliser ce binding. Wonder offre une possibilité entre plus simple, le else ! Situé après un WOConditionnal, son contenu ne sera affiché qu’à condition que celle du WOConditionnal ne le soit pas. Ce composant n’a aucun binding.

Inline tags

<wo:else> … </wo:else>

Aller plus loin

Ce tutoriel s’arrête ici. Le but n’est pas de faire toute la chevauchée avec vous mais simplement de vous mettre le pied à l’étrier. J’espère que vous suivez ces tutoriaux en faisant vos propres tentatives à côté et non pas simplement en lisant ces pages l’une après l’autre. La mise en application est très importante pour vérifier que vous avez mémorisé ce qui a été abordé et compris les principes.

Pour aller plus loin dans la création de votre propre application, voici une liste de noms de composants qui vous seront utiles. Vous avez un nom, cherchez simplement comment l’utiliser sur internet et dans le pire des cas, servez vous de la fonction d’auto-complétion d’eclipse pour comprendre le fonctionnement du composant. eclipse est un excellent outil pour apprendre notamment les bindings obligatoires.

Faites attention aux bindings GET et aux bindings GET/SET. Attention également aux chaînes de caractères, qui sont à mettre des fois sur le binding string et des fois sur value. Vous aurez remarqué d’ailleurs qu’il ne faut pas utiliser le même pour le WOHyperlink et le WOSubmitButton. Il n’y a pas vraiment de règle pour savoir lequel des deux il faudra utiliser, la seule chose certaine est que si le binding string existe, c’est celui à utiliser.

WOBody, WOForm, WORadioButton, WORadioButtonList, WOCheckBox, WOCheckBoxList, WOTextField, WOPasswordField, WOText, WOPopUpButton, WOResetButton, WOImage, AjaxModalDialog, …

Tout au long de ce tutoriel je vais considérer que vous avez déjà une connaissance normale du langage Java et d’eclipse. Si tel n’est pas le cas je vous conseille de vous former dans un premier temps sur ces outils car sinon vous risquez d’éprouver quelques difficultés à suivre ce qu’il se passe.

Pour ce tutoriel et les suivants, je m’inspire fortement des screencasts de David LeBer WebObjects, WOLips and Wonder tutorial part 1 et part 2 qui sont disponible sur le site de WOCommunity avec tous les autres screencasts que je vous recommande vraiment.

Vous pouvez aussi utiliser la version PDF de ce tutoriel et si vous souhaitez le traduire je me ferais un plaisir de le publier ici même.

Créer un projet Wonder

Première étape, nous allons créer dans notre joli eclipse disposant du plug-in WOLips un projet Wonder.
Vous êtes habitué à eclipse donc aucune difficulté jusqu’ici: File > New > Wonder Application.

Première étape, le nom du projet. Pour illustrer notre tutoriel, nous allons créer une petite application permettant à un utilisateur de créer sa collection de séries et de se souvenir du dernier épisode regardé. Notre projet s’appellera donc « Series ». Vous pouvez également choisir votre workspace eclipse pour ce projet.

Deuxième étape vous pouvez choisir le package de base de vos classes et de vos composants. Le standart pour le package des composants est d’utiliser le package de base auquel est ajouté .components, c’est à dire que pour un package de base xxx.yyy vous utiliserez le package xxx.yyy.components. Dans notre exemple je vais utiliser comme racine com.pierreschambacher.series.

Etape intermédiaire, si vous avez d’autres projets vous pourrez indiquer que vous les utilisez dans votre nouvelle application. Si vous n’avez pas d’autre projet eclipse cet écran n’apparait normalement pas, s’il apparait choisissez next.

Dernière étape, l’import d’EOModels existants. Nous n’avons pas non plus d’EOModel existant, cliquez donc sur Finish. Pour information cette étape vous permettra d’utiliser un modèle déjà existant.

Vous pouvez voir qu’eclipse vient de créer votre projet avec tout un tas de dossiers, packages et fichiers déjà écrits.

Classes, packages, ressources, …

Faisons un tour des dossiers et fichiers générés pour maîtriser la structure de notre projet.

Sources

Tout d’abord vous remarquez trois classes dans le package de base que vous avez fourni au wizard: Application, DirectAction et Session.

Application

Il s’agit de votre classe main. Peu de choses sont à faire avec ce fichier si ce n’est de la configuration au démarrage comme l’indique le commentaire inséré par le template.

DirectAction

Les direct actions sont des méthodes dites « stateless ». Elles n’ont pas besoin d’une session, bien qu’il soit possible de la transmettre par cookie par exemple, et sont accessible directement par leur URL à tout moment et par n’importe qui. La méthode la plus classique que l’on trouvera dans un fichier de direct action est la méthode d’authentification sur un site web, car on ne souhaite par forcement qu’elle soit couplée à une page en particulier et n’est associée à aucune session.

Session

Comme son nom l’indique il s’agit de la classe qui sera instanciée pour créer des sessions pour les utilisateurs. Les attributs d’instance que vous y ajouté dureront aussi longtemps que la session de l’utilisateur durera. C’est ici généralement que l’on retrouve stocké l’utilisateur connecté et quelques autres informations. Lorsque vous vous trouvez dans un composant WebObjects, la session est simplement accessible à l’aide de la méthode session() qui par défaut demandera un cast vers le type Session de votre projet, le type renvoyé étant une classe de plus haut niveau.

Dans le package components se trouve un unique fichier.

Main

Ce fichier au nom un peu trompeur ne contient pas le main de votre application (il est dans la classe Application, regardez juste au dessus :-p). Il s’agit de la page principale de votre application qui a été gentiment déjà créée pour vous. Ou plutôt une partie du composant Main, voir juste ci-dessous.

Components

À côté du dossier Sources, vous remarquez un autre dossier appelé Components qui contient un élément Main WO, et conjointement dans le package com.pierreschambacher.series.components vous remarquez un Main.java. Sachez donc qu’un composant graphique WebObjects est constitué de plusieurs éléments portant tous le même nom mais des extentions différentes:

• Composant.html: fichier de template contenant du texte, des balises html et des balises WebObjects. C’est le principal fichier sur lequel vous allez travailler.
• Composant.java: fichier de code qui permet de définir le comportement de votre page. N’oubliez pas que vous êtes cependant dans une vue et le code contenu ici devrait être minimaliste.
• Composant.wod: vous allez définir ici la nature des webobjects défini dans votre fichier HTML et mettre en place le binding des variables à l’aide du fichier java, mais j’y reviendrais plus tard.
• Composant.api: définition des bindings visibles depuis l’extérieur de votre composant. Vous pouvez définir qu’un binding est requis pour obliger le programmeur à vous le fournir par la suite.
• Composant.woo: contient des informations comme la version de WebObjects, l’encodage des caractères et la configuration des DisplayGroups. Nous n’aborderons pas ce fichier, inutile d’y toucher.

Libraries

Rien de particulier ici, il s’agit du dossier où déposer les fichiers jar nécéssaires à votre projet avant de les ajouter dans votre Build Path.

Resources

C’est dans ce dossier que se trouve le fichier de configuration Properties. C’est également ici que plus tard nous ajouterons notre modèle mais il est encore trop tôt pour cela.

WebServerRessources

Images, vidéos, fichiers de style CSS … les ressources statiques de votre site vont ici. Vous êtes libre de les organiser dans une hiérarchie de dossier.

woproject

NE TOUCHEZ PAS !! :-p

Run as …

Rien de compliqué pour cette opération. Faites un clic droit sur votre projet, choisissez « Run as… » ou plutôt « Debug as… », puis WOApplication.
eclipse recherche le main et vous demande de lui indiquer lequel choisir, prenez bien évidemment celui qui se trouve dans votre classe Application (dans mon cas dans le package com.pierreschambacher.series).

À cette étape, votre navigateur préféré se lance et affiche le message « Hello World ». Bravo vous venez de lancer votre première application WebObjects.

Modifier un composant

Maintenant que vous avez pris connaissance de l’arborescence de votre nouveau projet, nous allons essayer de le modifier un petit peu !

REMARQUE IMPORTANTE: dans la mesure du possible lorsque vous avez une instance de l’application en train de fonctionner et que vous modifiez du code, WOLips va essayer de modifier votre instance « à chaud ». Des fois votre modification permettra un tel remplacement mais des fois le changement sera trop important pour le permettre et vous aurez une fenêtre d’alerte « Hot Code Replace Failed » vous demandant quoi faire. Ne vous inquietez pas, contentez vous de cliquer sur « Terminate » afin de tuer l’instance courante. Vous aurez simplement à relancer l’application une fois vos modifications terminées.

Ouvrez le dossier Components et double-cliquez sur Main et sa petite icône de pièce de puzzle. Eclipse ouvre une fenêtre partagée horizontalement en deux. La partie haute contient du HTML tout ce qu’il y a de plus classique et la partie basse est vide complètement.

Mon premier WebObject

Vous remarquez dans le code HTML une message « Hello World ». Supprimez ce texte et rentrez à la place la balise suivante:

<webobject name = « helloString » />

Si vous sauvegardez maintenant, vous remarquez d’eclipse n’est pas très heureux parce que vous utilisé un WebObject helloString qu’il ne connait pas. Ajoutez donc les lignes suivantes dans la partie basse de la fenêtre jusqu’à présent encore vite:

helloString: WOString {

}

Sauvegardez et vous remarquez qu’eclipse n’est toujours pas heureux parce que vous utilisez un WOString sans définir le binding « value » qui est requit ! Insérez donc entre les accolades:

value = « Hello World ! »;

Et cette fois si après sauvegarde, eclipse est heureux. Relancez l’application et vous devriez avoir votre Hello World ! affiché dans votre navigateur préféré. Vous pouvez changer la chaîne de caractère pour ce que vous voulez, sauvegarder et actualiser la page, vous remarquez que le message affiché dans le navigateur change !
Cependant sachez qu’il existe deux façon d’écrire les templates WebObjects. Vous venez d’utilisé l’ancienne façon, voyons à présent la nouvelle écrire apportée par le projet Wonder et que personnellement je préfère.

Supprimez complètement le contenu de la fenêtre du bas, le fichier WOD. Dans le fichier HTML, supprimez votre balise <webobject> et remplacez la par celle-ci:

<wo:str value = « Hello World ! » />

Vous remarquez que l’on a plus besoin de nommer notre variable ce qui je vous l’assure est un gros point positif. De plus à l’usage cette notation est plus pratique pour relire un fichier et savoir rapidement ce qu’il fait car on sait immédiatement ce que fait une balise sans avoir à consulter le WOD. Relancez l’application pour vérifier que tout va bien.

Un peu de dynamisme

Afficher une chaîne de caractère, c’est bien mais on voudrait pouvoir afficher quelqu’un d’un peu plus dynamique. Nous sommes au XXIème siècle quand même !

Chaîne de caractère

Dirigez vous vers votre fichier Main.java. Ajoutez une méthode currentTime renvoyant un objet String comme suit:

public String currentTime() {
return new java.util.Date().toString();
}

À présent dans votre fichier Main.html, remplacez dans la balise wo:str le value= »Hello World ! » par value= »$currentTime ». La présente du caractère $ indique qu’il s’agit d’un binding. WebObjects va alors rechercher dans le fichier Java:

1. une méthode getCurrentTime renvoyant un objet et ne prenant aucun paramètre
2. une méthode publique nommée currentTime, renvoyant un objet et ne prenant aucun paramètre
3. un attribut public nommé currentTime

Vous aurez compris dans notre cas que WebObjects sera satisfait de trouver notre méthode fraichement créée. Dans le cas où plusieurs de ces éléments existent, ils sont choisis dans l’ordre indiqué, c’est donc une méthode get qui sera choisie en premier.

Relancez l’application, vous voyez l’heure actuelle affichée dans votre navigateur. Si vous actualisez la page, l’heure est mise à jour.

Une date

Nous avons renvoyé une chaîne de caractère afin d’afficher la date dans notre fenêtre. Cependant il existe une façon un peu plus propre de faire la même chose.

Changez la signature de la méthode currentTime, qui ne renvoie plus un objet String mais un objet NSTimestamp. Il suffit de créer une nouvelle instance de cet objet:

public NSTimestamp currentTime() {
return new NSTimestamp();
}

Vous constatez alors que votre page affiche l’heure actuelle, mais il faut bien le dire, dans un format absolument dégueulasse ! Il faut à tout prix remédier à cela.
Non non, modifier la méthode dans le fichier java n’est pas une bonne idée, ajoutez plutôt l’attribut dateFormat à votre balise wo:str comme suit:

<wo:str value = « $currentTime » dateformat = « HH:mm:ss dd/MM/yyyy » />

Actualisez la page … c’est mieux non ?

Un peu d’Histoire

WebObjects a été développé par la société NeXT en Objective C. Les classes utilisées en Objective C sont précédées par NS (NeXT Step). La société est rachetée plus tard par Apple mais les classes garderont historiquement ce préfixe. À partir de la version 4 de WebObjects, Java remplace petit à petit l’Objective C jusqu’à l’avoir complètement remplacé aujourd’hui mais afin de ne pas perdre les personnes ayant développé pendant longtemps en Objective C, les méthodes du framework ont été porté vers Java avec leur nom et leurs méthodes. Ce choix est fait au détriment en revanche des programmeurs Java qui devront apprendre à remplacer leurs classes habituelles par celles de WebObjects.

Comme vous l’avez vu dans l’exemple précédent, il faudra utiliser NSTimestamp en lui et place d’une Date.
Pour les tableaux, oubliez l’ArrayList, vous allez utiliser les classes NSArray et NSMutableArray. Pourquoi deux classes me direz vous ? Comme leur nom l’indique, l’un est un tableau, l’autre un tableau modifiable. Si vous avez besoin en paramètre d’un tableau que vous n’allez pas modifier, indiquez qu’il s’agit d’un NSArray, mais si vous avez l’intention de changer son contenu utilisez NSMutableArray. Si vous avez un NSArray et que vous tenez absolument à pouvoir effectuer des modifications sur ses éléments vous disposez de la méthode mutableClone qui créera un clone de votre NSArray en version Mutable.
Pour les dictionnaires, oubliez la HashMap et dites bonjour à NSDictionary et NSMutableDictionary . Je vous renvoie au paragraphe précédent pour le Mutable/non Mutable.
Si vous aimez utiliser les Sets, utilisez NSSet et NSMutableSet.

Interaction avec l’utilisateur

Suffit d’afficher la date dans son navigateur sauf si vous êtes en train de créer horloge-parlante.com ! Nous allons inviter l’utilisateur à rentrer son nom et le saluer pour le remercier.

Mise en place

Modifiez votre fichier HTML pour obtenir le résultat suivant dans la partie body:

<wo:form>
Enter your name: <wo:textfield value = « $username » />
<wo:submit value = « Say hi » action = « $sayHi » />
</wo:form>
<br />
<h1>Hello <wo:str value = « $username » /> !</h1>

Si vous sauvez, vous constaterez d’eclipse n’est pas vraiment heureux parce qu’il ne trouve pas username et sayHi dans votre fichier Java. Nous allons résoudre le problème. Ne quittez pas le fichier HTML, maintenez le bouton Command enfoncé et placez votre souris sur $username, vous remarquez que le nom se transforme en lien. Si vous cliquez, eclipse vous indique qu’il ne trouve pas username dans votre fichier Java et se propose de le créer pour vous. Voyons les différents éléments de cette boîte de dialogue

• les boutons radio vous permettent de choisir si votre binding est un objet, un NSArray d’objets ou un NSMutableArray d’objet.
• le champ texte permet de choisir le type de notre objet, ici java.lang.String nous convient parfaitement.
• les checkbox suivantes permettent de demander la génération d’un attribut, d’un get et d’un set, ce qui est coché par défaut. Vous pouvez choisir de mettre « get » ou non sur le getter avec la dernière checkbox.

Dans notre cas tout est configuré comme il faut, faite simplement OK et vous vous retrouvez dans le fichier Java où vous constatez qu’eclipse s’est chargé de générer un attribut privé username, une méthode publique username qui renvoie cet attribut et une méthode setUsername qui s’occupe de peupler l’attribut. Concernant username eclipse est heureux.

Retournez dans le fichier HTML, command-clic sur $sayHi qui est une action et remarquez que cette fois ci eclipse propose de créer une méthode renvoyant un objet de type WOActionResult. Cliquez sur OK la configuration par défaut nous convient. Voici la méthode générée:

public WOActionResults sayHi() {
return null;
}

Petite explication. Les actions sont des méthodes qui permettent de définir un comportement sur une action de l’utilisateur, par exemple ici le clic sur le bouton submit.
L’objet retourné par une action est très important car il définit la prochaine page à afficher. Si la méthode retourne null, alors c’est la même page qui est regardée, sinon c’est la page retournée qui sera envoyée au client. Pour créer une page différente, utilisez la méthode pageWithName qui possède deux signatures. Nous y reviendrons un peu plus tard dans ce tutoriel dans la section « Deuxième composant ».

Dans le cas présent, il suffit de recharger la page courante, donc laissez la méthode générée telle quelle. Sauvegardez tout et lancez l’application, ça fonctionne, magique non ?

Explications

Vous n’avez pas l’impression d’avoir fait grand chose et pourtant ça marche. Faisons un petit retour sur le fonctionnement de cette page.

Concernant le wo:str, vous voyez qu’il y a un binding de value sur username, donc de façon très simple au moment du chargement de la page la méthode username est appelée et insérée dans la page. Rien n’a changé par rapport à tout à l’heure.

Pour le wo:textfield et le wo:submit, vous avez mis en place un binding à l’aide de l’élément value du textfield sur username. Donc au chargement de la page la valeur de username est utilisée pour remplir le textfield, mais dans le cas d’un retour d’informations, comme c’est le cas avec le clic sur le bouton submit, c’est la méthode SET qui est appelée pour modifier la valeur dans le fichier Java avec la valeur que l’utilisateur a mis dans son navigateur. Comme l’action du bouton submit renvoie null, la même page est rechargée avec cette fois ci username différent de null.

Vous l’aurez compris, certains bindings fonctionnent uniquement en GET, comme le value du wo:str, et d’autres fonctionnent en GET et SET comme le value du textfield. Consultez la documentation pour savoir à quel type de binding vous avez affaire, de toute façon c’est généralement assez explicite. Dernier type de binding, les actions pour réagir aux actions utilisateurs. Quelque chose que vous remarquez rapidement, votre fichier HTML a connaissance des éléments publiques de votre fichier Java, mais ce dernier ignore totalement l’existence de la page HTML. Tout fonctionne par bindings, il faudra vous habituer.

Améliorations

Première chose, vous avez remarqué qu’au premier chargement il est simplement affiché « Hello  ! » ce qui est un peu bête. Ajoutez sur votre wo:str le binding suivant:

valueWhenEmpty = « World »

Rafraichissez la page. Mieux non ?
Deuxième petite amélioration-démonstration, sur le binding value du wo:str, changez le pour mettre ceci:

value = « $username.toUpperCase »

Rafraichissez de nouveau. Vous aurez compris, rien n’empêche dans un binding d’utiliser un chaînage de méthodes.

Deuxième Composant

Dernier point que nous aborderons sur ce tutoriel, nous allons créer un deuxième composant et créer un lien entre les deux.

Sur le dossier Components, faite un clic droit New > WOComponent. Entrez comme nom « About » et assurez vous que la superclass est er.extensions.components.ERXComponent et que la case « Create HTML contents » soit cochée. Vous avez votre deuxième composant WebObjects. Mettez ce que vous souhaitez dans le HTML pour reconnaitre votre page About puis retournez dans votre page Main. Ajoutez un nouveau composant dans le HTML comme ceci:

<wo:link string = « About » action = « $openAbout » />

Comme tout à l’heure, command-clic sur openAbout et laissez eclipse créer le squelette de la méthode pour vous. Dans le code remplacez le return null par ceci:

return pageWithName(About.class);

Vous disposez également de la signature suivante:

return pageWithName(About.class.getName());

Lorsque vous utilisez la méthode pageWithName, utilisez toujours le style MonComposant.class et jamais « MonComposant ». Cela au cas où vous souhaiteriez renommer votre composant un jour. La méthode pageWithName va instancier votre composant et l’initialiser, et en étant retourné par l’action vous indiquez à WebObjects qu’il s’agit de la prochaine page à afficher. Compilez et lancez l’application et observez le résultat.

Conclusion

Suite à ce tutoriel vous devriez avoir compris comment créer une page, y insérer du HTML et des composants mélangés. Vous savez mettre en place des bindings avec le code Java, changer la page courante, créer des données dynamiques. Vous êtes cependant un peu léger concernant les composants que vous connaissez, le prochain tutoriel sera consacré à la liste des principaux composants que l’on utilise 80% du temps.

Nom dans le dock

Ici c’est la manoeuvre la plus simple. Repérez dans votre dock le eclipse que vous souhaitez renommez, clic droit, [Snow Leopard] menu Options, [/Snow Leopard] Afficher dans le Finder.
Vous devriez voir votre Eclipse.app. Renommez ce fichier avec le nom que vous souhaitez, si par exemple comme moi vous avez un eclipse spécialement pour WOLips, appelez le WOLips.app. Pour que le changement prenne effet immédiatement, supprimez l’ancienne icône du dock et cliquez-glissez l’application renommée vers le dock.

Icône dans le dock

Reproduisez la manoeuvre précédente pour arriver jusqu’au fichier .app, faites un clic droit dessus et choisissez « Affichier le contenu du paquet ». Une nouvelle fenêtre s’ouvre avec un dossier « Contents » qui contient lui-même un dossier « MacOS » et un dossier « Resources ». Ouvrez le dossier Resources et vous êtes devant l’icône utilisée par eclipse au format icns. Je vous conseille de renommer cette icône en Eclipse_old.icns afin de pouvoir éventuellement la remettre en place un jour, puis placez dans ce dossier l’icône que vous souhaitez utiliser avec pour nom « Eclipse.icns ».

Le format à utiliser n’est pas jpg ou png mais icns. Je vous recommande cet utilitaire pour transformer vos images en fichier icône. Privilégiez le format png en entrée avec une bonne gestion de la transparence et une bonne résolution (idéalement 512×512 minimum) pour ne pas avoir une icône dégueulasse dans votre joli dock.

Nom dans la barre de menu

Vous remarquerez que malgré que vous ayez changé le nom du fichier .app, l’application une fois lancée s’appelle toujours Eclipse dans la barre de menu (tout en haut à gauche, à côté de l’icône Pomme).
Pour changer cela, direction le fichier eclipse.ini qui se trouve dans le fichier .app (reproduire la manoeuvre indiquée pour le changement d’icône) dans le dossier Contents/MacOS. Modifiez ce fichier avec un éditeur texte quelconque et ajoutez simplement une ligne:

-Xdock:icon=../Resources/Eclipse.icns
-Xdock:name=WOLips

Si vous regardez votre fichier la ligne Xdock:icon existe déjà. Il suffit d’ajouter -Xdock:name= suivi du nom que vous souhaitez utiliser pour votre application, probablement le même que celui que vous avez donné à l’icône dans le dock.

Mémoire autorisée pour l’application

Selon l’usage que vous faite de votre instance d’eclipse, vous pouvez avoir des besoins particulier en mémoire. Si par exemple vous utilisez le plug-in Flex Builder 3 et sa gestion pitoyable de la mémoire, vous risquez d’être confronté à des ralentissements du fait du trop faible espace mémoire dédié à l’application. Inversement, vous utilisez peut-être plusieurs instances d’eclipse en même temps et vous tenez absolument à ne pas swapper, et vous souhaitez donc que chaque instance utilise une quantité maximum de mémoire précise qui évitera de déborder de votre quantité de RAM.
Retournez donc dans le fichier eclipse.ini situé dans Eclipse.app/Contents/MacOS et repérez les deux lignes suivantes:

-Xms128m
-Xmx1024m

Si vous n’avez rien touché les valeurs après Xms et Xmx devraient différer ce celles-ci. Le chiffre suivant Xms est la quantité minimum de mémoire allouée à eclipse, et celle après Xmx est la quantité maximum qui lui sera dédiée. Étant donné que je dispose de 4Go de RAM que j’exploite peu, la quantité maximum est réglée sur 1Go afin d’éviter des ralentissements dans eclipse. À vous de juger de la quantité adéquat pour votre machine et votre utilisation d’eclipse.

Appel aux lecteurs

Je suis toujours à la recherche d’une personnalisation supplémentaire. Malgré tous ces changements, Spaces identifie toujours les deux instances d’eclipse comme une seule application. Il est donc impossible d’indiquer que l’instance « eclipse normal » va sur la Space 1, et que l’instance « eclipse WOLips » va sur le Space 2. Si un lecteur passant par là sait ce qu’il faut toujours pour que Spaces soit capable de distinguer les deux applications, je suis preneur !! Laissez un commentaire, merci . Si vous avez d’autres idées de personnalisation, partagez aussi d’ailleurs.

Présentation rapide

Développer en WebObjects se fait sous Mac OS X avec eclipse équipé du plug-in WoLips.
À l’origine WebObjects est développé et maintenu par Apple. Toutefois ils sont assez lents à apporter des mises à jours notamment pour correspondre aux besoins du web moderne comme par exemple des composants Ajax. Pour combler ces manques, le projet Wonder a été créé. Celui-ci est OpenSource et propose non pas d’être une surcouche à WebObjects (dans le sens couche logicielle par dessus une autre) mais remplace la plupart des classes du framework par un équivalent qui dans la plupart des cas hérite du composant d’origine. En clair, vous n’allez plus utiliser un WOTextField mais un ERXTextField, qui hérite de WOTextfield et lui ajoute quelques nouveautés.

De ce que j’en sais, il est possible de développer en WebObjects sous Windows mais Apple ne le supporte pas … Je n’aborderais pas ce point mais si quelqu’un a l’expérience de développement WO sous Windows, libre à lui de laisser un commentaire.

Une version imprimable de ce tutoriel est disponible au format PDF.

Base de données

Le développement en WebObjects se fait généralement au dessus d’une base de données. Assurez vous donc d’en avoir une d’installée sur votre machine.
J’ai personnellement fait le choix d’utiliser MySQL 5.1 avec le MySQL GUI Tools pour l’administrer. Certains puristes vous orienteraient plutôt vers Frontbase, je n’entrerais pas dans le débat.

Pour cette partie je vous laisse faire, vous disposez qui plus est peut-être déjà d’une base de donnée sur votre machine donc autant l’utiliser. Il suffira de s’adapter dans les prochains tutoriels lors de la configuration de la base de données, ce qui n’est vraiment pas difficile.

Eclipse

Comme vous pourrez le voir sur le site de la WO Community la version 3.5 d’eclipse n’est pas vraiment recommandée pour faire du développement WebObjects. Orientez vous donc vers la version 3.4 et de préférence en version développement J2EE notamment pour la gestion de ant et d’autres parties bien pratiques. Vous trouverez l’archive d’eclipse sur cette page: eclipse ganymede.

Quelques conseils à propos de eclipse. Dès que vous l’avez installé, rendez vous dans le menu des Préférences afin d’y effectuer quelques changements:

• dans General > Workspace mettez l’encodage du texte par défaut sur UTF-8
• dans General > Workspace toujours mettez la fin de ligne sur Unix, c’est à dire ‘\n’
• dans General > Keys assignez un raccourci qui vous convient pour « Content Assist » (qui affiche l’aide pour auto-complétion)
• dans General > Keys assignez un raccourci qui vous convient pour la génération de Getter et Setter, c’est plus pratique pour travailler vite

Pour le reste, je vous renvoie à mon billet sur les raccourcis claviers, sections General et Eclipse.

WebObjects

Sauf indication contraire, je vous oriente vers la version 5.4.3 qui est disponible à cette adresse. Si vous utilisez Mac OS 10.5 il est possible que vous ayez une version récente d’installée. Pour les utilisateur de la 10.6 dite Snow Leopard, WebObjects n’est plus installée par défaut. Utilisez donc le lien que je viens de fournir.

Wonder

Vous trouverez les fichiers nécessaires au bon fonctionnement de Wonder sur leur site officiel. Prenez le fichier Wonder-latest-Frameworks suivi de la version de WebObjects que vous avez choisi (5.3 ou 5.4).
Une fois l’archive récupérée et décompressez, déplacez tous les dossiers .framework vers /Library/Frameworks. Félicitation, vous avez installé Wonder.

WOLips

Maintenant qu’eclipse est correctement installé, il est temps d’ajouter le plug-in WOLips.
Celui ci est très simple à installer. Direction le menu « Help » puis « Software Updates… » tout en bas du menu. Ouvrez le panneau « Available Software » et repérez à droite le bouton « Add Site… ».

L’adresse du dépot est la suivante: http://webobjects.mdimension.com/hudson/job/WOLipsStable/lastSuccessfulBuild/artifact/site/
Une fois  le nouveau dépot disponible, déroulez le et choisissez dans Standart Install les paquets WOLips, WOLips Base, WOLips Goodies Mac et WOLips Third Party Feature. Cliquez sur Install, acceptez le contrat de licence et à la fin de la barre de progression, eclipse vous indiquera qu’il souhaite redémarrer. Une fois cela fait vous disposez à présent de la Perspective « WOLips », et vous pouvez créer un projet de type « WebObjects Application » ou « Wonder Application ».

Félicitations

Vous venez de terminer l’installation de votre environnement de travail pour attaquer le développement sur WebObjects.
Le prochain tutoriel abordera la création de mon premier projet, son premier model et la mise en place d’une première page.

Contrat signé

Tout d’abord une bonne nouvelle pour les personnes qui ont suivi ma recherche d’emploi: je suis recruté en tant qu’ingénieur dans la société Intellicore afin d’y effectuer du développement WebObjects.  J’ai signé mon contrat et je suis actuellement en période d’essai. Beaucoup d’excitation pour ce premier contrat de travail, je donnerai quelques retours prochainement.
Merci à tous ceux qui ont suivi l’évolution de ma recherche et m’ont fourni des contacts.

Mise à jour de Wordpress et nouveau thème

Histoire que vous sachiez que je ne laisse pas mon blog à l’abandon, wordpress vient d’être mis à jour à la dernière version à savoir 2.8.5 comblant les dernières failles de sécurités découvertes.
Pour fêter mon changement de statut j’ai décidé de changer le thème du blog. J’espère que le nouveau vous plait. J’ai fait quelques modifications afin de corriger quelques traductions manquantes ou enlever des bugs du thème. Si vous remarquez un problème n’hésitez pas à m’en faire part j’essaierai de le corriger dans la mesure du possible.

Tutoriaux WebObjects

Actuellement je visionne des podcasts mis à disposition par la communauté WebObjects. Je suis en train de préparer un premier billet qui devrait arriver dans la journée. Surveillez mon flux RSS ça devrait arriver bientôt

Expert bien avant l’heure

Flex est une technologie jeune qui a le vent en poupe depuis peu. Combien de personnes en France peuvent justifier une expérience professionnelle d’un an de développement sur ce framework ? Peu.
Aussi malgré le fait que je sorte à peine d’école, je suis considéré comme « Expert Flex ». Les propositions qui m’ont été faites sur Flex était simples: vous savez des choses, utilisez les ! Mais ça ne colle pas vraiment avec ma vision du premier emploi. Je n’ai pas l’âge d’être un expert, j’ai envie d’apprendre des choses, découvrir de nouvelles possibilités. J’ai envie que mon entreprise m’apporte quelque chose en retour du travail que je fournis, et non pas livrer mes connaissances sans en avoir en retour, ou trop peu.

Outil principalement graphique

Lorsque l’on fait une application il y a deux aspects: la logique métier et l’aspect graphique.
Personnellement c’est la logique métier qui m’amuse le plus, la réflexion sur le modèle, les algorithmes, … Faire les fenêtres ne me dérange pas mais je ne suis pas bon d’une part, et je n’ai pas envie de me prendre la tête avec d’autre part. Le soucis avec Flex est que l’on passe la plupart de son temps à travailler sur l’aspect graphique. La principale préoccupation dans le développement en Flex est d’encastrer correctement les éléments d’interface tout en trouvant comment contourner les limitations imposées pour arriver à ce que l’on veut …
Après, je parle pour moi-même ! De très nombreuses personnes s’éclatent sans doute à faire des interfaces bien agencées mais ce n’est pas mon cas, et ça transforme donc souvent Flex en source d’ennui.

Limitations …

Je l’ai abordé précédemment, le framework en version 3 est par endroit vraiment mal foutu. L’API est pauvre, certaines choses sont mal pensées et on finit rapidement par passer plus de temps à réfléchir sur les difficultés de l’outil que sur l’application sur laquelle on travaille… Depuis quelques jours j’ai recommencé à faire du Java et je suis en permanence impressionné par la rapidité et la facilité avec laquelle j’avance. Inutile de luter contre le langage et le framework, au contraire ils aident à aller plus vite !!!
Pour reprendre le point précédent, je dirais qu’avec Flex on passe 20% de son temps à faire du code métier, 30% de son temps à coder des contournements du framework et 50% de son temps à lutter avec les composants graphiques. Un outil bien peu productif donc au final.

Enfermement

Après avoir vu l’effet d’une expérience d’un an, je n’ai pas envie de voir comment je serais traité si je venais à avoir une expérience de 5 ans en Flex… En tant que jeune diplômé j’ai encore la possibilité facilement de changer d’horizon car les entreprises tolèrent que je débute, mais d’ici quelques années ce sera sans doute plus difficile à faire.
J’évite cet enfermement d’une part parce que je ne me vois pas faire du Flex toute ma carrière, mais aussi parce que cela peut s’avérer dangereux. Miser toute ma carrière sur une technologie qui aura peut-être complètement disparu dans quelques années n’est pas rassurant. Même si Flex est à la mode en ce moment, qui sait ce qu’il adviendra dans les 5 ans à venir ? Notamment avec son étroite collaboration avec Flash que beaucoup de gens voudraient voir disparaitre de leur navigateur…

Tout d’abord, vous pouvez librement télécharger mon cours (bien que sans doute peu explicite sans le discours prévu pour l’accompagner) ainsi que le TP.

Bonjour, je suis votre prof aujourd’hui

C’est assez impressionnant de rentrer dans une salle pour y faire cours, et que tous les élèves viennent vous saluer en arrivant… car en effet il y a encore un mois j’étais un étudiant comme eux et je connaissais déjà la plupart de mes élèves. Évidemment cela aide d’une part à être en confiance et d’autre part à avoir le calme dans la classe

Le Cours

Concernant le cours en lui-même, je savais que je serais probablement limite pour tenir les 2h prévues, mais la réalité s’est avéré encore pire que prévue. Une fois devant cette 15aine d’étudiants (et amis) je n’ai pas pu m’empêcher de tracer à vive allure, enchaînant slide sur slide et arrivant au bout bien plus vite que prévu… Certains m’ont dit en fin du cours qu’ils auraient aimé que je ralentisse mais personne n’a osé m’interrompre, dommage

J’ai eu un certain nombre de questions en fin de cours, portant plus sur les cas où Flex est un bon choix que sur des points techniques, c’est bon signe d’une part sur l’explication que j’en ai faite et sur leur maturité de réflexion d’autre part. Dommage en revanche que mon expérience Flex se soit faite sur un projet confidentiel, m’empêchant de dire beaucoup…

Le TP

Après une longue séance « install party » de Flex Builder, nous voilà partis pour un TP avec pour objectif de développer un client Twitter. Je suis assez satisfait dans le sens où beaucoup sont allé assez loin dans un petit projet qui pouvait s’avérer ardu pour un néophyte. J’ai même quelques étudiants n’ayant jamais vu Flex (ou JavaFX ni Silverlight) qui sont arrivés à terminer le client avec toutes les fonctionnalités demandées (Yohann si tu me lis ).
Autre chose que j’ai remarqué, beaucoup ont préféré me pauser des questions sur la marche à suivre plutôt que de chercher sur Google, j’espère que c’était parce qu’il s’agissait d’un cours et qu’ils ont bien le réflexe de chercher sur internet ailleurs. En tout cas j’ai été bien occupé pendant ces 2h et je remercie encore Christian et Sandie qui m’ont assisté pour répondre à toutes les questions. En tout cas, coup de chance mis à part un plantage d’une configuration eclipse j’ai pu répondre à toutes les questions

Au final, quoi dire ?

Premièrement j’ai ressenti la certaine « expertise » pour laquelle on m’a demandé d’intervenir dans le sens où je ne sais plus vraiment ce qui est évident et ce qui ne l’est pas. Le TP notamment contient de nombreuses explications de choses qui ont été lues en diagonales car évidentes, mais en revanche je ne dis rien sur le fonctionnement d’un HTTPService qui n’est pas des plus simples pour le néophyte. Si j’avais à recommencer je m’aiderais surement de quelqu’un n’ayant jamais touché à Flex pour vérifier que je n’oublie pas de parler d’un point difficile et que je ne m’étends pas sur une évidence.
Deuxièmement j’ai été surpris par la rapidité de compréhension de mon auditoire. Comme je l’ai déjà dit nombreux sont ceux qui se sont bien avancé dans le TP et plusieurs l’ont terminé. Je ne pense pas que ma prestation ait quelque chose à voir là dedans, je pense tout simplement avoir eu un bon auditoire attentif et sérieux et je sais ma chance sur ce point.
Troisièmement et dernièrement, un cours est quelque chose de long à préparer. Il m’a fallu une bonne demi journée pour préparer ma présentation et encore un peu plus pour le TP. L’élaboration du TP est vraiment longue du fait que l’on code quelque chose, qu’on en vérifie la robustesse, et il faut ensuite trouver comment guider les élèves à faire ce que l’on vient de faire, en les aidant un peu mais pas trop non plus. Malgré le temps que j’ai consacré à toute cette préparation, le cours était très loin d’être parfait mais j’espère que j’aurais l’occasion une prochaine fois de faire mieux.

Vous vous lancez dans un petit projet perso ? Vous aurez toutes les clés en main pour que GIT soit votre gestionnaire de versions sur ce projet.

Cet article ne se veut pas exhaustif mais reflète le résultat d’un usage quotidien par un autodidacte. Si vous souhaitez corriger une éventuelle erreur ou partager une connaissance, n’hésitez pas à laisser un commentaire.
Il est recommandé pour la bonne compréhension de cet article de connaitre SVN.
L’auteur du tutoriel est un utilisateur Linux et certaines commandes peuvent poser problème sur d’autres système (notamment gitk).

Note à nos amis sous Windows: vous pouvez utiliser git sur Windows à l’aide de msysgit disponible ici.

Tout d’abord qu’est ce que git ?! Et bien avant d’être un logiciel de gestion de versions décentralisé (ou DSCM pour Distributed Source Code Management) il a été conçu comme un système de fichiers avec un système de versionning, le tout construit pour la performance. Et quoi de plus normal quand on sait qu’il était destiné à être le système de gestion de versions du noyau Linux en remplacement de BitKeeper. Git a été écrit par Junio Hamano et Linus Torvald lui même. Bref on a entre les mains un gros bébé, pourtant simple à utiliser et performant : tout est instantané !
On entend par décentralisé le fait de pouvoir « commiter » et faire évoluer un bout de code en local indépendamment d’un serveur central (contrairement à svn qui nécessite un serveur central), cela offre un confort de développement très important car on ne commite que ce qui marche VRAIMENT. Bien sûr on a tout le loisir de travailler avec un serveur central, il est même possible de faire des ponts avec un serveur svn, mais l’aspect collaboratif ne sera pas abordé ici.

Comme pour svn, chaque commit donne lieu à une nouvelle version (ou révision). Git a choisit non pas d’utiliser des numéros de révision, mais un identifiant unique SHA-1 pour chaque commit (donc révision). Cela évite d’avoir des conflits entre les différentes révisions de toutes les branches de tous les clones du dépôt. Il n’est pas toujours nécessaire d’indiquer le SHA-1 complet d’un objet, mais seulement les premiers octets qui le différencie des autres objets. Si j’ai deux commits :
3bdc6feaa01b6b86a0f94acab32bc3ad4c207a5d
3bdc4d695b90545c891392a486da9a9e07c053b
je peux identifier le premier avec 3bdc6 et le second avec 3bdc4

Chaque commande git peut être appelée de deux manières différentes :

git commande

Après ces petites notions théoriques passons à la pratique !!

Par où qu’on commence ?

Et bien pour commencer il faut initialiser ou récupérer un dépôt. Avant d’initialiser un dépôt il faut renseigner quelques variables permettant de vous identifier lors des commit. Donc :

git config – -global user.name Grégory
git config – -global user.email greg@wordpress.com
git config – -global core.editor emacs
git init

L’avant dernière ligne est importante si vous ne savez/voulez pas utiliser vim comme éditeur de messages lors des commits. Un joli fichier ~/.gitconfig contiendra votre configuration pour les projets suivants. Si vous omettez le –global, les informations ne seront inscrites que pour le dépôt crée.

Il est aussi possible de récupérer un dépôt git déjà existant depuis : ssh, système de fichier local, internet (http://, ftp://, git://) :

git clone soutade@monserveur:/mondepot mondepot
git clone /mon/de/pot mondepot
git clone http://www.kernel.org/mondepot
…

Et maintenant qu’on a un beau dépôt ?!

Et bien il faut faire des opérations sur les fichiers :

Modification

emacs MonFichier.c

Ajout au dépôt

git add MonFichier.c

Renomage du fichier

git mv [-f] MonFichier.c MonFichier2.c

Si vous ne passez par cette commande, git considère que le fichier aura été supprimé et il faudra faire un git add sur le nouveau fichier.
-f pour forcer le rennomage (si le fichier existe)

Suppression

git rm [-f] [--cached] MonFichier.c

Si vous ajoutez l’option –cached, le fichier sera uniquement supprimé du gestionnaire de versions, mais pas du système de fichier.

Oui, mais maintenant ça compile !

Si ça compile, c’est que ça marche (…). Bref il est temps de commiter ! Mais avant j’effectue toujours deux opérations :

git status

Cela permet de voir les fichiers ajoutés/supprimés/modifiés, voir si on n’a rien oublié (un nouveau fichier par exemple). « Untracked files » correspond aux fichiers qui existent mais qui ne sont pas (encore) pris en compte dans le gestionnaire de versions.

git diff [- -color]

Avec cette opération on peut visualiser les modifications (au format « patch ») effectuées sur nos fichiers, cela va nous aider à renseigner le message du commit.

Cette commande peut prendre plusieurs options :

git diff [- -color] [<commit1>..<commit2>] [- -] [paths]

et toutes les options de diff

<commit1>..<commit2> est un intervalle de commits, sachant que <commit> peut être désigné sous la forme :

• le SHA-1 d’un commit
• le tag
• une référence depuis le commit courant

paths correspond à n fichiers

Apparté : Le commit courant

Dans git, le commit courant (ou dernier commit avant modifications) s’appelle HEAD. On peut accéder aux commits précédents en les référençant par rapport à HEAD :
HEAD^ : Père du commit courant
HEAD^^ : Grand père du commit courant
HEAD~n : ancêtre de nième génération de HEAD (grand grand … grand parent de HEAD)

Apparté : .gitignore

.gitignore est un fichier à créer dans le dépôt git pour ignorer un certains nombre de fichiers (dans git status). Par exemple tous les fichiers « MonFichier~ » crées par emacs. A chaque ligne on intègre une expression régulière pour le ou les fichiers à ignorer (*~ pour emacs):
Si la ligne fini par /, cela désigne un répertoire et tous ce qu’il y a dessous.
Si la ligne commence par !, on a la négation de l’expression.
Si la ligne est vide ou qu’elle commence par #, elle est ignorée.

Étant donné qu’on ne va pas re créer ce fichier pour chaque dépôt, on peut en spécifier un qui sera réutilisé à chaque fois (qui peut être composé avec un .gitignore interne au dépôt). Pour cela il faut créer un fichier quelconque avec les même règles que .gitignore et inscrire la variable globale core.excludesfile :

git config – -global core.excludesfile CheminFichier

Attention toutefois, le chemin ne supporte pas ~ (Référence à la racine du répertoire personnel).

Et le tant attendu :

git commit [-a] [-m « message »] [paths]

L’option -a (recommandée) permet d’ajouter toutes les modifications au dépôt, sinon il faut spécifier les fichiers dans paths ou faire explicitement un git add (même sur des fichiers modifiés) pour chaque fichier à intégrer au commit.
Si vous ne précisez pas le message sur la ligne de commande (-m), un éditeur va s’ouvrir (vim par défaut) pour que vous entriez le message du commit. Le message du commit est obligatoire !

Un peu d’histoire

Maintenant qu’on a fait plusieurs commits et que notre projet grossi il peut être intéressant d’avoir un résumé de l’état du projet. Pour cela deux commandes :

git log [options] [<commit1>..<commit2>] [- -] [paths]

Liste des commits avec leurs message influant sur les fichiers paths.

git show [options] <commit> [- -] [paths]

Contenu de tous les fichiers modifiés ou seulement ceux dans paths.
Les options sont celles de git diff.

En ligne de commande la visualisation n’est pas aisée, c’est pourquoi je recommande l’utilisation de la commande gitk qui permettra d’avoir une vue graphique et synthétique du dépôt.

Eh Bob, j’ai une idée !

Oui, mais les idées de Bob c’est pas toujours terrible, heureusement git permet de créer FACILEMENT des branches, pas besoin d’appeler la gconf et d’imputer sur le budget du projet déjà en déficit …
Bref pour créer un branche :

git branch NomDeLaBranche [BrancheInitiale]

Et voilà la branche est crée à partir de HEAD ou de BrancheInitiale.

ATTENTION vous êtes toujours dans la branche de départ, pour pouvoir changer de branche il faut faire un :

git checkout NomDeLaBranche

Pour récupérer uniquement un fichier d’une autre branche :

git checkout AutreBranche paths

Ces deux actions peuvent être combinée en :

git checkout -b NomDeLaBranche [BrancheInitiale]

Bon ben en fait Bob il a des idées toutes pourries, suppression de la branche :

git branch -d NomDeLaBranche

ATTENTION la branche sera détruite sans confirmation, toutes les modifications seront perdues et il ne sera pas possible de les retrouver !!

On peut lister les branches avec :

git branch

Pour voir le contenu d’un fichier d’une autre branche :

git show MaBranche:MonFichier

Oui, mais mon idée était beaucoup plus classe que celle de Bob, je vais donc l’intégrer dans la branche principale (master) :

git checkout master
git merge MesBranches

(on peut merger depuis plusieurs branches)
S’il n’y a pas de conflit, l’opération est commitée (sauf option –no-commit).

Ah il y a un conflit que git n’est pas capable de résoudre: il nous l’indique et il faut le résoudre  manuellement. Le fichier accusé sera de la forme :

<<<<<<< HEAD:test.c
printf(« Hello world 2\n ») ;
=======
printf(« Hello world 1\n ») ;
>>>>>>> test:test.c

HEAD, c’est la branche actuelle ! test est ici une branche de test. Le fichier en conflit sera affiché dans git status comme unmerged.

Pas très lisible ?  On peut voir séparément les différences introduites par les deux commits sur le fichier en conflit :

git log –merge -p test.c

Une autre option très pratique pour choisir entre telle et telle version quand on est fainéant et qu’on n’a pas envie de tout éditer à la main (de toutes façons c’est ma version la meilleure) :

git show :z:test.c

où z correspond à :

• l’ancêtre commun des deux branches
• branche actuelle
• branche distante

Qui montre la version z du fichier test.c. On redirige ensuite la sortie dans le fichier test.c

Ne pas oublier de commiter les changements introduits par le merge (en cas de conflits) !

On a enfin une version stable !!

Il est possible de la tagger pour avoir une référence un peu plus explicite que son SHA-1.

git tag MonTag [<commit>]

Par défaut HEAD de la branche courante. Un commit peut avoir plusieurs tags.

Ah, en fait non, Bob avait laissé un buffer overflow, supprimer un tag :

git tag -d MonTag

Ouais, en fait la v1 c’était le top. Il est possible de revenir à une version précédente (et heureusement) via trois techniques.

Je m’appelle Rambo et rien ne me fait peur

git reset [--mixed | --soft | --hard] [<commit>]

Ici on revient à un commit précédent en SUPPRIMANT tous les commits suivants
–mixed : les changements n’affectent que le gestionnaire de versions et pas le système de fichier
–soft : On revient simplement au commit <commit> au niveau du gestionnaire de versions, mais les fichiers ne sont pas changés sur le disque (un prochain commit n’effacera pas le commit suivante [i.e qu'on a reseté])
–hard : Le gestionnaire de versions et les fichiers sur le disque se retrouvent en position <commit>, les commits suivants sont perdus.

Méthode propre

git revert <commit>

Cette méthode est « propre » car elle permet de conserver les changements introduits (même si on veut s’en séparer) en introduisant un commit faisant le travail inverse de ce qui a été cassé.

Méthode pour un ensemble restreint de fichiers

git checkout <commit> paths

Cela permet de retrouver ponctuellement un fichier d’une ancienne version.

J’te jure ça marchait et j’ai rien touché !

12 commits ont été réalisé pendant que vous étiez en vacances et maintenant plus rien ne compile (Bob ??). Bref, git offre un mécanisme très puissant pour identifier le commit qui a tout fait planter : bisect ! On va pouvoir faire une recherche semi-automatique voir même automatique du commit fautif, git se chargera tout seul de mettre l’espace de travail tel qu’il était à chaque commit (sinon il aurait fallu jouer avec reset/revert).

On commence par démarrer une session de bisect en identifiant le point où ça bloque (en général HEAD) et le point où on est sûr que c’était bon:

git bisect start [<commit-bad>] [<commit-good>]

Puis on va identifier les différents commits (la recherche est dichotomique, c’est à dire qu’il prend toujours le commit intermédiaire dans l’intervalle good-bad afin de trouver au plus vite la version responsable du problème) avec :

git bisect bad
git bisect good

Chaque appel de cette commande « tag » le commit avec good ou bad et passe au commit suivant jusqu’à tomber sur le fautif (ou qu’on en ais marre). Si on sait qu’un commit (ou un intervalle de commits (ie : v1..v2)) est bon par avance on peux l’ignorer avec :

git bisect skip [<commit>[..<commit>]]

good et bad ne sont que des marqueurs, il appartient ensuite au développeur d’effectuer les actions pour retrouver un environnement correct/stable/sans bugs. On peut visualiser l’état des marqueurs (dans gitk) avec :

git bisect visualize

Une fois qu’on a fini le boulot on peut revenir au point de départ (effacer les tags et retour à HEAD) avec :

git bisect reset

Il est possible d’enregistrer toutes les opérations (ou au moins les « visualiser ») avec :

git bisect log

Et on peut ensuite les rejouer avec :

git bisect replay <fichier créée par git bisect log>

Mais là où git est très intéressant c’est avec le mode tout automatique :

git bisect run cmd

cmd est une commande (ou un script) qui va être appliqué sur tous les commits entre bad et good et qui va les marquer selon son code de retour :

• 0 : good
• 125 : skip
• autre : bad

Une fois qu’on a le commit fautif on peut savoir exactement qui a fait quoi dans le fichier qui a fait que et quand il l’a fait :

git blame <paths>

Ce qui donne quelque chose comme :

1692b633 (Grégory 2009-09-19  1 ) #include <stdio.h>
1692b633 (Grégory 2009-09-19  2 )
1692b633 (Grégory 2009-09-19  3 )
1692b633 (Grégory 2009-09-19  4 )
1692b633 (Grégory 2009-09-19  5 ) int main()
1692b633 (Grégory 2009-09-19  6 ) {
795a06c9 (Grégory 2009-09-29  7 )   printf( « Hello world\n » ) ;
1692b633 (Grégory 2009-09-19  8 )
1692b633 (Grégory 2009-09-19  9 )   return 0 ;
1692b633 (Grégory 2009-09-19 10) }

Git, mon couteau Suisse

Quelques commandes supplémentaires :

Exporter les sources du projet (sans le .git)

git archive –format=[tar|zip] –output=File <commit> [paths ...]

Appliquer un/des patch(s)

git apply <patchs>

Supprimer les fichiers qui sont dans le dépôt, mais pas dans le gestionnaire de versions (untracked files) :

git clean [-d] [fichiers]

Si l’argument fichiers est renseigné, seuls ces fichiers là seront supprimés.
-d : Supprimer aussi les dossiers

Optimiser le dépôt local pour de meilleures performances (à faire de temps en temps)

git gc

Pour aller plus loin

La documentation de git (en pages man) est très bien faite, il y a deux solutions :

git help command

Toutes les options pour les commandes présentées n’ont pas été spécifiées ici, je vous recommande donc pour certaines tâches spécifiques d’aller voir le man.
L’aspect travail collaboratif (pull, push, rebase) n’a pas été abordé, si vous êtes curieux il y a d’autres documentation qui en parlent (peut être pour une prochaine version de ce tutoriel).

Pour savoir pourquoi git est le meilleur gestionnaire de versions du noyau : http://www.youtube.com/watch?v=4XpnKHJAok8

Le Terminal c’est bien, mais bon

Vous devriez maintenant être capable d’utiliser git en ligne de commande pour vos besoins personnels. Le terminal … ça va bien un moment mais on aime aussi avoir un client graphique un peu plus convivial qui fait le boulot pour nous ! Faisons un petit tour d’horizon des solutions existantes. Malheureusement, je n’ai pas pu tester ces solutions, libre à vous donc de vous faire une opinion sur l’état d’avancement et la fiabilité de chacun, n’hésitez pas à laisser un commentaire pour partager vos retours.

QGit: Client Qt4 (donc pour les utilisateur KDE principalement). Hébergé par SourceForce avec une dernière version datée du 9 Mai de cette année. De bons retours indiqués sur le site.

TortoiseGIT: Client Windows se voulant le remplaçant de TortoiseSVN. Nécessite l’installation préalable de msysgit.

GitX: Application pour Mac OS X.

GitNub: Autre application pour Mac OS X écrite en RubyCocoa.

EGit: Plug-in pour eclipse, malheureusement peu avancé. Si vous avez du temps et de la motivation, n’hésitez pas à participer.

Ressources

http://git-scm.com/

http://fr.wikipedia.org/wiki/Git

http://www.kernel.org/pub/software/scm/git/docs/gittutorial.html
http://linux.efrei.fr/doku.php/tutoriaux/git
http://github.com/
http://www.unixgarden.com/index.php/administration-systeme/git-pour-les-futurs-barbus
http://www.unixgarden.com/index.php/administration-systeme/git-les-mains-dans-le-cambouis

Il me restera de cette expérience des connaissances sur Flex et Java/WebObjects, mais aussi beaucoup de choses sur l’architecture logicielle, l’organisation dans les petites entreprises, la gestion de projet, les rapports humain et bien d’autre chose encore.

Je ne sais pas encore où je vais travailler. Actuellement je cherche toujours un emploi (voir mon CV).
Plus de nouvelles bientôt.

À venir bientôt un tutoriel très complet sur GIT, la version en ligne de mon cours sur Flex à Polytech’Nice Sophia et j’espère pouvoir me lancer et parler de mes premières impressions sur COCOA.