Introduction

Pendant longtemps j'ai considéré qu'une tablette tactile ne me servirait à rien. Mes usages ne l'imposaient pas du tout et je ne suis pas du genre à acheter un nouveau gadget technologique si je n'y pré-sens pas un réel intérêt.

Puis ces derniers mois, je me suis rendu compte que mon usage de mon smartphone avait évolué et finalement se faisait en grande partie dans mon lit et plus majoritairement dans les transports. Dans ce contexte le fait qu'il soit petit n'apporte environ rien mais fait perdre considérablement en terme de lisibilité. Du coup la tablette devenait intéressante. De plus c'était l'occasion de reporter le remplacement de mon iPhone qui était motivé essentiellement par la petite taille de son écran.

Partant de là restait à en choisir une.

Premier candidat possible : l'iPad. Ça aurait été cohérent avec l'iPhone mais tant qu'à faire c'était l'occasion de passer à un truc moins cloisonné, censuré, dirigé et verrouillé. Bref, exit Apple. De toutes façons, je ne compte pas rester sur un iPhone pour ces mêmes raisons.

À part ça on a essentiellement de l'Android. Plein de fabricants font plein de tablettes qui se ressemblent toutes et c'est pas évident de choisir. Je suis passé à la Fnac pour tester un petit peu ce qu'il avaient mais je n'étais pas vraiment emballé : sur la plupart même le défilement d'un bureau à l'autre n'était pas vraiment fluide... Rien de très enthousiasmant.

Puis je suis tombé sur le test de l'ASUS Transformer Pad TF300T (oui ils sont doué pour trouver des noms courts et faciles à retenir...) de La Chaine Techno qui m'a plutôt bien convaincu : un clavier, de bonnes performances, tout ça. Je suis donc repassé par la Fnac pour confirmer que celle là offrait bien un défilement fluide au moins sur les fonctions de base puis je suis rentré chez moi la commander sur le net là où le prix était intéressant (faut pas déconner non plus).

La tablette en elle-meme

Bon, clairement c'est déjà pas une tablette bas de gamme (en même temps si c'est pour acheter de la merde, autant rien acheter du tout, ça évite de regretter une semaine après) puisque l'ensemble m'a coûté environ 500€ pour :
- la tablette
- le dock clavier
- une housse et une carte mémoire de 32Go supplémentaire

Donc comme je le disais plus haut, niveau performances, c'est correct : c'est globalement assez fluide à part de temps en temps quelques ralentissements sur Firefox. Le tactile est réactif et plutôt précis, je n'ai pas senti de différence notable par rapport à l'iPhone, donc techniquement ça fonctionne bien. L'autonomie est pour l'instant très bonne (à voir comment se comportera la batterie sur la durée).

Le doc clavier et bon aussi avec un clavier AZERTY pas trop petit et qui remplace le clavier tactile lorsqu'il est branché (ce qui libère significativement de la place sur l'écran). De plus il contient également une batterie, ce qui double l'autonomie de l'appareil, donc c'est plutôt pas mal.

Seul reproche (mais pas spécifique à celle-ci en particulier) : encore un câble spé pour connecter la tablette au PC ou à une prise de courant. Certes USB d'un côté mais avec une nouvelle prise spé de l'autre qui ressemble furieusement à celle de l'iPhone avec quelques millimètres en moins... Quand les fabricants vont-ils enfin se mettre d'accord là dessus ? J'ai bien peur que ça ne puisse pas arriver tant qu'aucune loi ne les y obligera (et accessoirement que les brevets les en dissuaderont)... dommage, parce que c'est bien chiant de ne pas pouvoir répartir tous ces câbles sur nos différents lieux d'utilisation plutôt que de devoir les trimbaler à chaque fois (ou les acheter chacun en x+n exemplaires).

Maintenant le côté logiciel

Déjà premier point : après plusieurs années à utiliser un iPhone, je redécouvre le bonheur de transférer des fichier dessus sans passer par la case imposée iTunes \o/ Eh oui, pouvoir simplement brancher la tablette sur son PC et accéder à son système de fichier directement. La base quoi. Ça semble évident comme ça mais chez Apple ça n'existe pas.

À part ça c'est mon premier appareil sur Android, et globalement ça passe plutôt bien. Quelques trucs auxquels il faut se faire au début mais globalement c'est comparable à l'iPhone avec quelques petits points un peu moins agréables en terme d'ergonomie et d'autres largement meilleurs.

Le plus gros point fort c'est la navigation entre les applications. Sur l'iPhone, même s'ils ont introduit le multitâche il y a quelque temps, c'est quand même assez rare d'arriver à passer d'une appli à l'autre sans perdre son contexte (genre si vous espérez retrouver le tweet que vous étiez en train de taper sur l'appli Twitter en après un saut sur le client mail, vous allez vite déchanter). Là les applis restent vraiment ouvertes (bon à l'inverse elles restent peut-être un peu trop ouvertes mais bon, je préfère ça personnellement ça marche mieux à l'usage) et le bouton de retour qui vaut autant au sein de l'application que d'une application à l'autre est juste très pratique.

Autre point fort : on peut installer des applications sans passer par un quelconque "store". Donc ça veut dire que si je veux faire un appli et la diffuser à un public restreint sans payer la taxe Apple (plusieurs 10aines d'euro par an rien que pour avoir le droit de mettre un truc sur l'AppStore, même pour une diffusion gratuite). Et du coup le corollaire c'est qu'on est pas bridé à des navigateurs basé sur le moteur de rendu Apple (le dernier pour Safari et le précédent pour les autres). Je peux donc installer un Firefox mobile avec adblock ou un Opera mobile et ça c'est BIEN. Ça me permet de contribuer à ralentir la transformation déjà bien entamée de webkit en IE6 pour les mobile (c'est-à-dire un moteur omniprésent et des sites conçus uniquement pour lui excluant d'emblée tout autre acteur) en faisant baisser sa part de marché.

Enfin un autre point très positif : les applis natives imposées par le constructeur, ben on peut les désactiver. Si si c'est vrai, ça parait fou comme ça mais c'est vrai. Bon faut chercher un peu mais ça se fait. J'ai pu virer les Google+, Gmail et autres qui s'entêtaient à vouloir se relancer continuellement en tâche de fond alors que je ne m'en sers pas.

Bon après ça reste du Google, donc c'est pas non plus le paradis. On a l'impression de vendre son âme en démarrant la tablette la première fois. Puis on se tape de la pub ici ou là (mais finalement pas tellement plus que depuis l'arrivée d'iAd chez Apple) et on se fait sans doute espionner à tout va (mais là non plus Apple n'est sans doute pas en reste). L'idéal aurait été un OS libre piloté par une organisation sans but lucratif mais pour l'instant c'est pas encore trop ça... De deux maux il faut choisir le moindre. En l'occurrence je ne fais pas plus confiance à Google qu'à Apple mais au moins j'ai plus d'ouverture sur l'usage de ma tablette, c'est déjà ça.

Y a aussi quelques points ergonomiques discutables et des habitudes qu'on aurait bien aimé garder de l'iPhone mais qui ne sont pas transposables mais globalement après une semaine d'utilisation je m'y suis fait et à par l'effet de "rebond" marquant le bas d'une fenêtre (qui est sans doute breveté Apple, d'où son absence de la plupart des applis), je ne trouve pas vraiment de gros points noirs sur l'ergonomie.

Sur le store et les applications, je trouve par contre assez gênant l'absence de signalétique disant si l'appli est compatible avec de grand écrans ou non. En effet un certain nombre d'applications ne "scalent" pas ou très mal sur un écran de tablette et sont manifestement optimisées uniquement pour les téléphones. Ça fait souvent tester plusieurs applis avant d'en trouver une satisfaisante (raison de plus pour ne jamais en acheter... ce que je ne prévoyais pas de faire de toutes façons).

Enfin un point gênant : Firefox a un bug avec le clavier et passe en clavier anglais pour les champs de formulaires alors qu'il gère bien le clavier français pour la barre d'adresse. J'espère que ce bug sera vite corrigé..

Conclusion

Pour l'instant je suis plutôt satisfait de mon achat et ne le regrette pas. Ça me confirme également dans mon idée qu'actuellement la concurrence a largement rattrapé Apple sur le segment des appareils mobiles et qu'on peut donc largement s'en passer.

L'iPad est sans doute au moins aussi bon technologiquement et je l'ai écarté d'emblée pour sa fermeture. Ces considération idéologiques sur le caractère ouvert du système peuvent paraitre accessoires puisqu'au final on arrive à faire la majorité de ce qu'on veut vraiment faire sur un iPhone ou un iPad. Mais est-il vraiment raisonnable de continuer à valider les systèmes fermés d'une société si d'autres options sont disponibles avec un niveau de qualité proche ?

Voici un autre module Change que je suis en train de développer. Pour le coup il répond à un besoin très spécifique et correspond plus à un extranet qu'à un site web classique. Mais bon, puisque moi j'en avais besoin, peut-être que d'autres en auront l'usage aussi. Ou pas mais on peut difficilement savoir avant d'en parler

De quoi s'agit-il ?

Depuis des années, j'achète souvent sur le net, en particulier des biens culturels et ludiques : livres, mangas, DVD CD, jeux de plateaux, jeux à collectionner, jeux vidéos, etc. Grouper les achats permet en général de réduire les frais de port et en bonus allège un peu le coût écologique total des livraisons. Donc on a pris l'habitude avec mes frère, sœur et parents principalement de grouper nos achats de ce type. Ceci implique de gérer des comptes puisqu'à chaque commande, une seule personne paye effectivement et le autres doivent le rembourser. Le même principe vaut pour les cadeaux groupés ou autres courses occasionnellement faites pour le compte des autres.

S'échanger du liquide à chaque fois c'est chiant, donc pendant longtemps on est passés par du mail pour se tenir au courant de l'état du solde de chacun. Mais le mail c'est quand même assez peu adapté : quand on se plante et qu'on part du mauvais mail pour calculer les nouveaux soldes ou quand on se demande si on a bien pensé à prendre en compte tel ou tel achat c'est vite le bazar. Puis faut faire tous les calculs à la main, c'est lourd et ça introduit un risque d'erreur non négligeable.

Du coup comme on est quand même une famille de développeurs on se disait que faire une appli web accessible de n'importe où pour gérer tout ça ce serait cool et ça nous faciliterait la vie (enfin sauf ma mère qui elle se cantonne en général à rappeler qu'en achetant moins ça serait tout de suite plus simple mais avant de prendre sa retraite elle était prof de maths, pas informaticienne, donc on lui pardonne). Comme toujours, avec les supers solutions ça s'est éternisé quelques temps à l'état de projet hypothétique parce que bon, c'est bien beau de se dire qu'il faudrait le faire mais c'est quand même vachement plus simple que de le faire réellement.

Mais bon, un jour on se dit qu'au final si on veut pas arriver au point où on aura passé plus de temps à se dire qu'il faudrait le faire que le temps nécessaire pour le faire réellement il faut se lancer. Et donc il y a quelques mois j'ai pris mon courage à deux mains et finalisé une première version utilisable (loin d'être complète et ergonomiquement optimale mais utilisable).

Comme j'ai l'habitude de travailler avec Change, c'est donc un module Change. Ça aurait pu être fait avec n'importe quelle autre techno mais c'est celle là que je maitrise.

Bon et donc ça fait quoi concrètement ?

Pour l'instant ce module va vraiment à l'essentiel : il gère des "factures" (que j'aurais pu appeler aussi "transactions") correspondant à un achat dans une boutique avec le montant total payé, les réductions et les frais inclus dans ce total et enfin le détail des achats avec la répartition entre les acheteurs.

Formulaire de création d'une facture

L'outil valide la cohérence globale de ce qui est saisi, en particulier :
- les répartitions doivent correspondre au total des quantités saisies
- le montant payé doit correspondre au total des lignes après application des réductions et frais
On évite ainsi pas mal d'erreurs de saisie.

Validation de la cohérence de la facture

Une fois la facture enregistrée, la répartition des coûts entre les différents acheteurs est calculée (les réductions et frais indiqués étant répartis au prorata des achats) et leurs soldes sont automatiquement mis à jour. Les différents intervenants sont alors avertis par e-mail qu'une facture qui les concerne vient d'être saisie.

Détail d'une facture

On peut également consulter la liste des comptes utilisateurs avec leurs soldes et accéder au détail d'un compte qui donne la liste de ses factures.

Détail d'une facture

Détail d'un compte

Et enfin on peut également accéder à l'historique complet des factures enregistrées.

Liste des factures

C'est tout pour le moment, ce qui suffit à répondre nos besoins minimaux et apporte déjà nettement plus de simplicité que le mail et moins d'erreurs grâce aux différents contrôles de cohérence.

Évolutions envisagées

Même si l'ensemble répond au besoins minimaux, c'est encore loin d'être complet et ergonomique.

Gestion des boutiques

En effet, la création d'une nouvelle boutique implique de passer par le backoffice, ce qui est assez contraignant. De même il n'y a pas encore de listing des boutiques sur le site qui permettrait de suivre l'historique des dépenses dans chacune d'entre elles.

Saisie des factures

La saisie des factures est encore assez figée : tous les comptes ont systématiquement leur colonne dédiée, ce qui fonctionne à note échelle actuelle de 5 personnes mais poserait des problèmes avec une plus grosse volumétrie (qui pourrait être vite atteinte si l'on ajoute des acheteurs plus occasionnels).

De même le nombre de lignes est figé d'autorité à 30, ce qui est à la fois beaucoup trop la plupart du temps et pas assez dans certains cas exceptionnels.

Modification et validation des factures

À l'heure actuelle, les factures sont "validées" automatiquement lors de leur saisie. C'est-à-dire qu'elles ne sont pas modifiables et que les soldes des intervenants sont mis à jour immédiatement.

Pour une utilisation plus pratique et rigoureuse il est prévu d'ajouter une validation par l'ensemble des intervenant avant de mettre à jour les soldes, ceci permettant de détecter les éventuelles erreurs. De plus tant qu'elle n'est pas validée par tout le monde, la facture restera modifiable, voire annulable.

Autres évolutions envisagées

D'autres évolutions seraient intéressantes à mettre en œuvre :

• Gestion de versements directs : dans notre cas, certaines personnes passent plus fréquemment des commandes que d'autres. Il en résulte que les soldes ont tendance à se déséquilibrer, déséquilibres qui se règlent en général par un versement (liquide, chèque, virement...). Il serait donc intéressant de pouvoir matérialiser dans une entrée dédiée un versement direct d'une personne à une autre dans un formulaire simplifié.
• Pour certains achats (au hasard les cadeaux), il peut être pratique de ne rendre visibles certaines commandes (voire certaines lignes seulement) que par les personnes concernées (notamment pas le destinataire du cadeau).

Je ne dis pas que tout sera fait et encore moins sous quels délais mais dans l'idée c'est pour l'instant l'essentiel qu'on ait détecté comme évolutions à faire pour améliorer l'appli.

Accès au code

Comme la plupart de mes modules, celui-ci a vocation à être publié (d'ailleurs en théorie l'Afero GPL l'impose un peu) une fois qu'il sera suffisamment finalisé. Je compte également l'archiver dans un repository publique mais je n'ai pas encore tranché entre passer par un site existant genre GitHub ou SourceForge comme pour mes précédents modules (qui aurait l'avantage d'une mise en place simplifiée) et m'installer un repository local sur mon serveur avec un accès web au fichiers (qui d'un côté me plait mieux parce que je garde la maitrise de mon repository plutôt que de le stocker sur une plateforme tierce centralisée mais implique de passer du temps à le mettre en place).

Quoiqu'il en soit, si jamais quelqu'un est intéressé (sait-on sait jamais) je peux déjà lui fournir la version actuelle sur simple demande ^^

Activer la correction orthographique sur les champs textes mono-ligne

Par défaut Firefox n'active la correction orthographique sur les champs texte multi-lignes. Il est possible également de l'activer sur les champs mono-ligne simplement par configuration (pas besoin d'extension pour ça).

La manip' est la suivante :

1. dans la barre d'URL, taper about:config pour accéder aux variables de configuration de Firefox
2. lire l'avertissement si vous ne l'avez pas déjà fait et cliquer sur "Je ferai attention, promis !"
3. dans le champ de recherche, taper layout.spellcheckDefault
4. double-cliquer sur la ligne dont le nom est layout.spellcheckDefault

Les autres valeurs possibles sont :

• 0 : aucune correction
• 1 : champs multi-lignes seulement
• 2 : champs multi et mono lignes

(source)

Firefox 13 : changer la page de l'ouverture d'un nouvel onglet

Firefox 13 arrive avec par défaut dans les nouveaux onglet un diaporama des sites que vous consultez le plus souvent. Si je peux concevoir que ça puisse servir à certaines personnes, en ce qui me concerne ce n'est pas le cas.

En effet, les sites que je consulte souvent, soit j'ai un signet pour y accéder tout aussi vite, soit ils arrivent en première suggestion en tapant une à trois des premières lettres dans la barre d'URL... Pas besoin d'un gros visuel pour ça.

Autre point : moi qui utilise beaucoup l'historique de navigation sur les onglets, pour revenir à l'accueil des sites que je consulte souvent (que j'ouvre en général dans des onglets dédiés), ça ne m'arrange pas du tout que la première entrée de cet historique soit squattée par une liste de miniatures inutiles plutôt que la page par laquelle je suis arrivé sur le site.

L'avantage de Firefox par rapport à d'autres logiciels c'est qu'assez souvent quand ils ajoutent une fonctionnalité à la con copiant Chrome, c'est qu'on peut la désactiver pour peu de savoir quelle clé de configuration changer. Celle-ci n'échappe heureusement pas à la règle

La manip à faire est donc similaire à celle du point précédent :

1. dans la barre d'URL, taper about:config pour accéder aux variables de configuration de Firefox
2. lire l'avertissement si vous ne l'avez pas déjà fait et cliquer sur "Je ferai attention, promis !"
3. dans le champ de recherche, taper newtab
4. double-cliquer sur la ligne dont le nom est browser.newtab.url et renseignez l'URL que vous voulez accéder via vos nouveaux onglets, ou about:blank si comme moi vous préférez une page vide qui ne polluera pas l'historique

Notons que si d'aventure vous souhaitez accéder à cette page il suffira de taper about:newtab dans la barre d'URL (que vous pouvez également mettre dans un signet si le cœur vous en dit).

(source)

Firefox 13 : désactiver les mises à jour silencieuses

Firefox 13 fait décidément beaucoup de choses qui ne me plaisent pas directement importées de Chrome. En l'occurrence je parle ici de la nouvelle option de mises à jour "silencieuses" automatiques du navigateur.

En soi je peux concevoir qu'on ait envie de l'activer pour ne plus avoir à s'en préoccuper mais personnellement je préfère choisir de valider volontairement une opération qui peut rendre mes extensions inutilisables ou casser le rendu de certains sites. Et surtout je préfère choisir moi-même le moment : en général pas lorsque je suis en train de faire un truc urgent ou quand je suis énervé pour une quelconque raison.

D'autant plus qu'à l'époque où Firefox suivait un cycle de release plus standard, on ne se posait vraiment de questions que pour les mises à jour majeures, les autres n'étant que des correctifs, le risque était faible. Maintenant toute mise à jour peut contenir des modifications majeures (ou pas la plupart du temps mais rien ne les différencie a priori), donc il est exclus pour moi d'activer des mises à jour automatiques sans validation de ma part sur une application aussi cruciale que mon navigateur.

Le hic c'est que cette nouveauté est semble activée par défaut lors du passage à Firefox 13 (en tous cas je ne me souviens pas avoir eu de dialogue qui me pose la question et hier quand j'ai appris son existence, j'ai constaté qu'elle était activée).

Heureusement elle reste désactivable facilement (même pas besoin de passer par about:config cette fois... quoique vu comme elle est loin dans les menus ça aurait peut-être été plus rapide :euh: ) :

1. aller dans le menu Outils > Options...
2. sélectionner l'onglet "Avancé" (le dernier en principe) puis le sous-onglet "Mise à jour
3. choisissez la seconde option "Vérifier l'existence de mises à jour mais me laisser décider de leur installation

(source)

Le but de cet article est de revenir sur les différentes méthodes de surcharge du code PHP qu'on a eu (et que pour beaucoup on a encore) dans RBS Change depuis que je travaille dessus (au départ en faisant des sites avec puis par la suite en tant que développeur du produit).

Je n'entrerai pas dans les détails concrets d'utilisation mais ça me semble intéressant de voir un peu l'évolution des concepts, les différentes tentatives qu'il y a eu et les raisons qui ont pu orienter certains choix.

En fin d'article je présente ce qui sera fait dans la version 4.0 dont la sortie n'est prévue que courant 2013. En conséquence, ce que j'évoque pourrait potentiellement encore évoluer d'ici là et ne reflète que ce qui a été mis en œuvre pour l'instant, pas une vérité gravée dans le marbre.

Écrasement des fichiers dans la webapp

J'ai commencé à travailler avec Change sur la version 1.2 en 2006. À cette époque le seul moyen offert pour surcharger du code du produit était d'écraser certains fichiers (PHP ou autres, cela fonctionnait pour tous les fichiers des modules et même du framework : PHP, XML, templates, styles, etc) dans le dossier "webapp". La mécanique était (trop) simple : à chaque chargement de fichier PHP, l'application commençait par le chercher dans le dossier webapp. S'il était présent cette version était chargée, sinon celle du code standard l'était. Le fichier de surcharge était donc contraint de reprendre l'intégralité du code qu'il surchargeait, même au cas où il réécrivait seulement une méthode d'une classe en comptant cinquante.

C'était toujours un peu mieux que de modifier directement le code du produit mais à peine puisque lors d'une mise à jour, il fallait passer sur chaque fichier surchargé pour ré-appliquer les modification.

Dès la version 2, l'année suivante, la possibilité de surcharge de code PHP directement dans le dossier webapp a été supprimée car elle posait beaucoup trop de problèmes. En remplacement, une autre méthode plus cadrée a été mise en place : "l'injection" de service et peu après, de document.

Injection de service et de document

L'injection de service (toujours d'actualité dans la version 3.6) fonctionne sur un principe qui reste très simple mais qui est nettement plus cadré. Dans la configuration projet déclare des injections consistant à dire "le servie A est à remplacer par le service B". Tous les service sont instanciés via une méthode getInstance() (selon le patron de conception singleton) qui inclut une mécanique qui va chercher dans la configuration projet si une injection a été déclarée sur ce service. S'il y en a une, on retourne une instance de la classe remplaçante au lieu de la classe appelée.

Le code travaille donc simplement avec une autre classe que celle qu'il a demandé. Pour que les choses marchent bien, il faut évidemment que la classe remplaçante étende la classe remplacée.

Peu après le même principe a été appliqué aux documents : en déclarant une injection de document on remplace son modèle, sa classe finale et son service là encore en renvoyant des instances de classes étendant celles que le code demande en réalité.

Globalement ça marche assez bien mais avec deux limitations :

1. Dans le cas où on injecte une classe déjà étendue par ailleurs, les classes étendues ne profiteront pas de l'injection. Par exemple, si une classe C étend A et que j'injecte A par une classe B. Si je demande une instance de A, j'obtiendrai une instance de B mais si je demande une instance de C j'obtiendrai une instance de C étendant A et non B.

   Cette limitation peut rapidement s'avérer gênante quand on développe des modules complexes avec des documents de base étendus par d'autres (par exemple les différents types de produits dans le module Catalogue et boutiques).

2. Une même classe ne peut être injectée qu'une seule fois. Cela peut devenir problématique si plusieurs modules veulent se greffer sur un module existant et ont besoin de remplacer du code : il faudra alors écrire une classe en spécifique dans le projet qui cumules les différentes modifications ce qui n'est pas très bon en terme de maintenabilité (on se rapproche à nouveau un peu de l'écrasement décrit plus haut même si ça reste plus restreint).

Points d'entrée spécifiques (stratégies, section "mvc" du project.xml, etc.)

Parallèlement à l'injection, d'autres mécaniques plus ciblées ont été mises en place dans certains modules pour permettre de remplacer du code standard par des implémentations spécifiques.

Les modules liés à l'e-commerce se sont ainsi enrichis d'un certain nombre de "stratégies" (du patron de conception strategy). Ces points d'entrée explicites permettent de choisir entre plusieurs implémentations pour un traitement donné. Par exemple on proposait une stratégie sur l'arrondi des prix avec une implémentation standard qui se contentait d'arrondir à deux chiffres après la virgule, là où certains projets avaient d'autres règles.

On trouve encore ce genre de chose en version 3.6, en particulier sur les points le choix n'est pas unique au sein d'un projet donné (par exemple le calcul du montant d'un frais : deux frais peuvent s'appliquer avec des stratégies de calcul différentes).

On en trouve encore quelques autres dont l'implémentation est choisie une fois pour toutes dans la configuration projet mais elles tendent à disparaitre (cette mécanique spécifiquement mise en place à chaque fois étant alors redondante avec les mécaniques génériques d'injection).

D'autres points d'entrée spécifiques ont été mis en place au fur et à mesure, notamment pour les différentes classes entrant en jeu dans le modèle MVC (notamment les différents contrôleurs) qui peuvent être remplacée via une section dédiée dans la configuration projet.

Dans tous les cas ces points d'entrée ont été mis en place spécifiquement dans certaines parties du code. Les mettre en place implique donc de prévoir volontairement que telle ou telle partie doit pouvoir être remplacé au contraire de l'injection qui fonctionne de manière plus globale.

Réécriture de classe et AOP

Dans la version 3.0 de Change, un nouveau mécanisme a été implémenté, tiré de certains concepts de la programmation orientée aspect (AOP).

Cette mécanique propose plusieurs choses reposant sur la réécriture des classes lors d'une phase de compilation.

Premièrement le remplacement d'une classe par une autre. Il s'agit là non pas de simplement retourner une instance d'une autre classe (comme c'était le cas avec l'injection décrite plus haut) mais bien de réécrire la classe pour y intégrer les modifications. Pour ce faire, on renomme la classe d'origine (avec un suffixe quelconque) puis on renomme la remplaçante avec le nom de l'originale. Ainsi le remplacement est totalement transparent pour le code qui l'entoure : il travaille bien physiquement avec une instance de la classe qu'il a demandé, à ceci près que cette classe a été modifiée.

Par exemple on part d'une classe A que l'on veut remplacer par une classe B (qui doit étendre A). On commence par renommer A en A_replaced0. Puis on renomme B en A et on la fait étendre A_replaced0. On obtient alors une nouvelle classe A qui a toutes les méthodes et propriétés de la classe B, y compris celles de la classe A d'origine.

Cette méthode fait sauter la limitation de l'injection décrite plus haut sur les classe étendues puisque du coup une classe C qui étendrait notre classe A d'origine héritera du même coup du code introduit par B. Dans son implémentation proposé dans la version 3.0 (qui reste la même en 3.6), elle ne fait par contre pas sauter l'autre limitation liée aux sources multiples.

Depuis la version 3.0, c'est sur cette mécanique que repose l'injection de documents et plus sur la mécanique décrite auparavant (ainsi une injection du document catalog/product se répercutera sur tous les documents qui l'étendent : catalog/simpleproduct, catalog/productdeclination, etc.).

Au delà de cette simple mécanique de réécriture (qui n'est pas de l'AOP à proprement parler mais juste un préalable), d'autres possibilités ont été mises en place permettant d'ajouter du code avant ou après l'exécution d'une méthode, d'ajouter une méthode à une classe ou d'en remplacer une (il s'agit là effectivement des concept de l'AOP). Là aussi on fait de la réécriture de classes mais avec l'avantage de pouvoir faire venir des modifications de plusieurs sources.

L'inconvénient est que dans les fait c'est un peu compliqué à comprendre et expliquer (le développeur web n'étant pas forcément familier avec ça) et pas forcément très lisible ni intuitif à écrire. Du coup finalement ça a été assez peu utilisé dans la pratique à part pour contourner la limitation sur les sources multiples ou bien pour agir sur des méthodes privées d'une classe (ce que permet dans une certaine mesure l’implémentation actuelle mais relève à mon sens un peu de l'hérésie... même si dans certains cas c'est tentant, réécrire des méthodes privées c'est réécrire du code qui n'est pas censé être accessible par l'extérieur et c'est très mauvais lors des mises à jour).

Injection de blocs

La dernière mécanique en date à avoir été mise en place est l'injection de blocs qui arrive avec la version 3.5.

Lorsqu'on insère un bloc dans une page, on ne référence pas directement un nom de classe mais un "type" (celui qui est indiqué dans le fichier blocks.xml du module) qui en pratique découle du nom de la classe. Mais a grosse différence avec les service c'est que le bloc n'est pas utilisé en tant que tel par du code des modules. Rien n'oblige donc au final à ce que le bloc finalement rendu soit réellement le bloc identifié par le type.

Lorsqu'on utilise un service on va faire appel à ses méthodes pour effectuer des traitements si une méthode manque ou n'a pas la bonne signature la plupart du temps ça finit avec une belle page dont le contenu commence par "Fatal error:". Lorsqu'on utilise un bloc, on va simplement lui demander de se rendre mais son implémentation importe peu en terme de réussite ou d'échec de l’exécution.

L'injection de bloc peut donc être nettement plus libre que l'injection de service ou le remplacement de classe. En effet, elle se contente de changer le mapping entre le "type" du bloc et la classe PHP effectivement utilisée sans obligation que la nouvelle classe étende la classe d'origine (du moment que ça reste un bloc). Si on reste sur un fonctionnement proche, on étendra le bloc d'origine mais si ce n'est pas le cas on peut aussi repartir d'une feuille blanche et le remplacer par une nouveau bloc totalement différent (voire étendant un autre bloc existant qui se rapproche plus de ce qu'on veut faire).

À venir en 4.0 : unification et simplification

Comme on a pu le voir, les méthodes de remplacement de code disponibles sont très nombreuses avec chacune leur limitations. De tout ce que j'ai pu évoquer, trois sortent du lot car elles apportent vraiment un plus en terme de possibilités (hors des limitation liées à l'implémentation). En effet toutes finalement visent à remplacer des classes par des classes qui les étendent une fois pour toutes globalement pour le projet à l'exception de :

• l'injection de document est un peu à part puisqu'elle implique plusieurs classes (modèle, classe finale du document, service) mais au final reste du remplacement de classe
• les stratégies dont le choix ne relève pas de la configuration projet mais se fait au cours de l'exécution selon le contexte (exemples : calcul de frais, calcul de réductions, etc)
• l'injection de blocs qui n'impose pas de reprendre le code du bloc existant mais peut repartir de zéro dans une autre direction si le besoin s'en fait sentir

Toutes les autres (injection de service, remplacement de classe, AOP, stratégies définies dans la configuration projet, remplacement de classes spécifiques) répondent bien au même besoin : introduire du code spécifique dans une classe existante en ciblant au mieux la partie réécrite pour avoir le moins de problème possible lors des mises à jour. En version 4.0 ces différentes mécaniques parallèles seront donc supprimées au profit d'une seule et unique mécanique reprenant le meilleur de chacune.

Elle s'appellera "injection de classe" et pourra d'une manière générale être appliquée à n'importe quelle classe (à part une poignée qui sont chargées trop tôt dans l'exécution pour pouvoir en profiter). Elle reposera sur le concept de réécriture de classe (comme la mécanique de remplacement de classe) et sera déclarée dans la section injection sur le modèle de l'injection de service actuel.

Reste à couvrir un point que permettait l'AOP : injecter une classe avec du code provenant de plusieurs sources. Conceptuellement, rien ne l'empêche. C'est uniquement l'implémentation mise en œuvre dans les versions précédentes qui ne le permettait pas.

En version 4.0, on pourra donc déclarer des "injections chainées" en gros au lieu d'indiquer une seule classe de remplacement, on pourra en indiquer plusieurs séparées par des virgules. La mécanique de remplacement sera appliquée successivement dans l'ordre indiqué.

Par exemple, si une classe A est déclarée injectée par trois classes B, C et D (qui doivent toujours toutes étendre A), on obtiendra la chaine d'extension suivante : A_injected0 (anciennement A), A_injected1 (anciennement B) qui étend A_injected0, A_injected2 (anciennement C) qui étend A_injected1 et enfin A (anciennement D) qui étend A_injected2. De cette manière plusieurs modules peuvent proposer leur injections spécifiques sans exclure les autres.

Ceci évitera au développeur de se retrouver à devoir choisir entre une multitude de mécaniques proches avec chacune ses limitations pour n'utiliser toujours qu'une seule et même mécanique simple à comprendre et à mettre en œuvre.

Conclusion

Voilà, j'ai fini mon petit tour de l'historique des méthodes de surcharge. Je me suis concentré sur ce qui est lié directement aux classes PHP, omettant volontairement tout ce qui a trait aux templates, styles et fichiers de configuration des modules (déjà comme ça ça donne un sacré pavé).

Comme je le disais en introduction, je ne suis volontairement pas entré dans les détails de mises en œuvre, pour cela référez-vous à la documentation de Change ou posez vos questions sur le forum.

Comme je l'ai dit également, la dernière partie concernant la version 4.0 ne reflète que l'état actuel des développement et pourrait éventuellement évoluer encore un peu d'ici la sortie. Mais globalement les grandes lignes devraient rester valables. On notera du coup qu'il n'est pas conseillé d'abuser de l'AOP dans un projet actuel car cela nécessitera beaucoup de boulot de migration vers la version 4.0 au contraire d'un remplacement de classe qui reste le plus proche de ce qu'on aura au final (c'est d'ailleurs pour cela que l'AOP n'a pas été documentée dans le wiki).

Voilà, félicitations à ceux qui liront mon pavé jusqu'au bout... à supposer qu'il y en ait :euh:

Supprimer un grand nombre de fichiers

Quand on a un très grand nombre de fichiers dans un dossier, un simple rm xxx* ne fonctionne pas forcément. J'ai eu le cas notamment avec des sessions PHP qui ne s'effaçaient pas correctement et qui du coup s'accumulaient en masse.

Une solution qui fonctionne est de passer par find :

find . -name 'sess_*' | xargs rm

(source)

Supprimer les .svn d'un répertoire

SVN place un dossier .svn dans chaque dossier d'un projet (contrairement à GIT qui se contente d'un unique dossier .git à la racine).

Pour supprimer l'ensemble des fichiers .svn d'une arborescence, on peut passer par cette commande qui utilise encore une fois find :

find -type d -a \( -iregex ".*/.svn" \) -exec rm -rf {} \;

Exclure des dossiers d'un grep

Pour exclure des dossiers d'un grep, on utilise l'option --exclude-dir. Par exemple pour exclure le dossier .git lors d'une recherche dans des fichiers :

rgrep 'toto' modules/ framework/ --exclude-dir=.git

Du coup pour mes recherches dans le code de Change, je me suis fait cet alias dans mon .bashrc :

alias crep='rgrep --exclude-dir=.git'

On peut également passer par l'option --exclude.

(source)

Exclure des dossiers d'un tar

Les archives de mon serveur devenant un peu trop grosses, j'ai dû mettre en place quelques exclusions de dossiers (par exemple ne plus sauvegarder les logs, caches et médias formatés de mes sites sous Change).

Pour cela je suis passé par l'option -X (ou --exclude-from=) de tar qui permet d'indiquer un fichier contenant les motifs à exclure.

Exemple :

tar cvf archive.tar /home/change -X exclude.txt

Avec un fichier exclude.txt contenant :

/home/change/repository
/home/change/instances/*/log
/home/change/instances/*/cache
/home/change/instances/*/build
/home/change/instances/*/media/formatted
/home/change/instances/*/www
/home/change/instances/*/repository

Attention les motifs sont comparés aux chemins tels que vous les avez décrits. Dans mon exemple, j'ai un chemin absolu pour le dossier à archiver, il faut dont des motifs qui matchent ce chemin. Si j'avais donné un chemin relatif, j'aurais dû revoir mes motifs d'exclusion en conséquence.

On peut également utiliser --exclude en indiquant directement un motif à exclure. Mais c'est moins pratique quand on a toute une liste d'exclusions.