Turbinagaz.com

On dirait bien...

2010-01-21T16:51:00+01:00

... qu'il va falloir que je me remette un peu au travail côté plugins, au moins un peu contraint et forcé.

Après plusieurs semaines de tests, le service Defensio annonce officiellement son passage en version 2.0. Pour l'occasion, l'API du service connait un vrai lifting et introduit la possibilité d'échanges asynchrones.

Tout motivé que je suis, j'ai récupéré les nouvelles spécifications de cette API v2. Il ne me reste donc plus qu'à la lire, la comprendre, la tester et de mettre à jour le plugin associé pour Dotclear.

Qui a dit qu'on n'était pas rendu ?! ;-)

En bref

2010-01-08T15:01:00+01:00

Suite du déballage des cartons : les différents liens présents dans les billets et concernant les téléchargements ont été actualisés et sont désormais fonctionnels et les nouvelles adresses d'abonnements sont en service (toujours via FeedBurner).

Bien que les anciennes adresses de flux restent actives pour quelques semaines encore, je vous invite à modifier vos lecteurs pour privilégier les nouvelles au plus tôt. A savoir :

http://feeds.turbinagaz.com/turbinagaz pour le fil des billets,
http://feeds.turbinagaz.com/turbinagaz-comments pour le fil des commentaires.

Les peintures vont rester en l'état pour un moment encore : pas trop de temps pour cela, et surtout une inspiration proche de zéro. Et puis il faudrait, en premier lieu, que je commence par ranger correctement le peu de choses à (re)mettre en ligne.

A peine trois bricoles et c'est déjà le bordel ambiant...

Hello Goodbye

2010-01-01T20:11:00+01:00

Furtivement, j'ai profité de ce changement d'année pour déménager ce petit blog consacré à Dotclear, en le renommant pour l'occasion.

Au revoir Bricoland Drive, bonjour Turbinagaz.

Période de fêtes oblige, comme j'avais également pas mal d'autres chats à fouetter, le dépaquetage des affaires s'est fait dans la hâte. Vous aurez donc droit à un beau bordel ambiant pendant quelques semaines, un habillage provisoire, des liens brisés et des redirections qui ne redirigeront pas (ou mal). Comprenez donc qu'il est préférable de ne rien bookmarker, de ne pas toucher aux abonnements, etc. On reparlera de cela en temps voulu.

Et puis, dans le fond, OSEF ! Il n'est pas question ici d'affaires d'état : superficialité, futilité et fun restent et resteront parmi les principales caractéristiques de ~~Bricoland Drive~~Turbinagaz.

Bon, c'est pas le tout. Faut que je file, il y a des restes à finir.
Ah, d'ailleurs...

Mes meilleurs vœux pour 2010. ;)

Les derniers jours de Bricoland Drive

2009-12-21T16:29:00+01:00

Oyez, oyez !

Tout est dans le titre : Bricoland Drive vit ses derniers jours, ici et sous cette forme.

Par contre, cela ne signifie pas que ce blog va disparaitre. Il va simplement changer de serveur, de domaine et probablement de nom.

La mutation s'effectuera quelque part entre maintenant et la fin de ce mois de décembre. La transition devrait se faire dans la douceur (ou presque), avec la mise en place de redirections et la publication d'un état des (nouveaux) lieux. D'ici quelques jours, les commentaires et trackbacks ne seront donc plus possibles, n'en soyez donc pas surpris.

A bientôt pour la suite, et bonnes fêtes à tous.

Microsoft, IIS et PHP sur Windows

2009-11-20T17:05:00+01:00

Depuis quelques temps, Microsoft semble faire du pied à PHP et sa communauté. Après avoir très longtemps poussé sa plateforme IIS/ASP(.Net) face à la plateforme LAMP, Microsoft a commencé à changer son fusil d'épaule en annonçant un partenariat avec Zend, fin 2006.

Afin de faire oublier le triste tableau qu'offrait le couple IIS/PHP (environnement souvent instable et peu performant), de véritables efforts ont été faits pour obtenir une cohabitation plus harmonieuse :

développement et mise à disposition d'un support FastCGI^[1],
développement d'un pilote PHP pour l'accès natif aux SGBDRs SQL Server 200x,
mais également le développement d'une extension PHP, Wincache, alternative pour plateforme Windows de l'extension APC.

Et pour faciliter l'installation de tout ce beau monde (entre autres^[2]), Microsoft livre dorénavant une solution nommée Web Plateform Installer. Il ne s'agit de rien d'autre qu'un assistant visuel vous permettant de naviguer dans une liste de composants disponibles pour votre environnement et de faire votre marché à grands coups de clics. Difficile de faire plus simple.

Pour en revenir à l'extension Wincache, elle sort aujourd'hui officiellement en version 1.0 stable, avec pour l'occasion une mise à jour de son entrée dans la documentation officielle de PHP et l'arrivée de sa section dans PECL.

Je l'utilisais depuis quelques semaines en version préliminaire et en étais assez content en terme de performances ressenties, sans pour autant savoir de quoi il en retournait vraiment. Mais comme le Web est un endroit magnifique, et que c'est jour de release, techPortal propose un rapide benchmark de Wincache 1.0.

Sur ce, je ferme cette longue parenthèse un peu hors-sujet - mais s'inscrivant dans le contexte du précédent billet - et retourne de ce pas dans le monde normal. :)

Notes

[1] Désormais embarqué par défaut dans les livraisons IIS 7.X

[2] Notez que pour l'occasion, je découvre - stupéfait - cette extension exotique qu'est APE. Il va absolument falloir que je teste ce machin !

Dotclear 2 mais... saveur Microsoft

2009-11-06T14:33:00+01:00

Quelle idée saugrenue ! Et pourtant, je suis bien décidé à garder un œil sur le comportement de Dotclear 2.x en environnement Microsoft.

Mais encore faut-il préciser ce que j'entends par environnement Microsoft : il ne s'agit pas de l'utilisation d'une pile Wampserver, mais bel et bien de l'utilisation de Dotclear 2.x sur des serveurs IIS. Oui, vous avez bien lu. :)

J'ai beau ne pas être un adepte de cette plateforme, je me dois de reconnaitre qu'elle figure parmi les principales du marché des serveurs Web et qu'en de telles conditions elle ne peut être ignorée. C'est donc une question de pragmatisme, avant tout, qui guidera cette démarche. Mais n'oublions pas non plus une grande part de curiosité et un fond d'intérêt professionnel.

Maintenant, comment cela se traduira-t-il dans les faits ?

Pour l'heure, le programme n'est que guère ambitieux :

s'assurer du bon fonctionnement de Dotclear 2.x sur les versions courantes de IIS, à savoir 5.x/6.x et 7.x,
obtenir peu à peu une bonne vue d'ensemble des performances et des limitations de Dotclear 2.x dans cet environnement,
acquérir quelques connaissances afin de pouvoir apporter des réponses sensées à d'éventuelles questions sur le forum,
voir s'il devient nécessaire de pousser plus avant le support des solutions Microsoft, et d'engager le cas échéant des développements supplémentaires.

Tout cela n'aura sans doute jamais le moindre impact marquant quant au projet Dotclear dans son ensemble. Tout au plus pourra-t-on envisager de voir apparaitre quelques patches et/ou aménagements discrets, ainsi que quelques compléments à la documentation actuelle.

La suite au prochain épisode ?

Dotclear 2 et les bonnes pratiques Opquast

2009-10-29T11:16:00+01:00

Il fallait s'y attendre, l'ami Franck a récidivé.

Pour les quelques vauriens qui ne suivraient pas son blog, Franck s'est de nouveau lancé dans un match Dotclear vs Opquast en confrontant cette fois la version actuelle de Dotclear 2.1.x aux bonnes pratiques recommandées par Opquast.

Un premier bilan de ce travail méticuleux est désormais en ligne.

Pour l'occasion, une poignée de tickets a également été soumise par Franck pour la suite du développement de Dotclear 2.x. A venir également, un ensemble de checklists à destination des différents profils susceptibles d'intervenir sur un blog propulsé par Dotclear 2.x.

Affaire à suivre de près, donc.

S'offrir le temps de la réflexion

2009-10-16T14:31:00+02:00

Au moment de coder, nous avons tous nos défauts. Plus ou moins nombreux, plus ou moins importants, plus ou moins évitables.

Il y a en certains qu'on peut corriger ou atténuer avec un peu de pratique, de discipline, de rigueur et quelques bonnes pratiques. Mais il y en a certains qui vous collent à la peau, et qui - malgré vos efforts - viennent pourrir vos séances d'écriture. Je pense que personne n'y échappe vraiment totalement.

Pour ma part, c'est mon naturel tête en l'air et mes doigts crochus qui me tendent régulièrement des pièges. Deux bons gros défauts, bien vicieux, qui n'attendent que les moments un peu plus détendus pour venir frapper en dessous de la ceinture : c'est-à-dire dans les parties de code les plus routinières.

Ils prennent la forme d'oublis idiots de choses pourtant évidentes, ou de fautes de frappe, les uns comme les autres m'étant gentiment signifiés par de doux messages d'insultes au moment des tests^[1].

Ah, évidemment, bien souvent, ce n'est rien de grave. Du pas bien méchant pas trop embêtant. Mais systématiquement, c'est une perte de temps d'autant plus frustrante que l'erreur l'ayant engendrée est stupide.

Figurez-vous que lorsque je développe un bout de quelque chose pour Dotclear, c'est souvent dans les zones banales que sont l'enregistrement de behaviors ou de balises de templates que ça se produit. Une typo dans le nom du callback par ci, l'oubli de la déclaration d'une nouvelle balise par là, etc. Rageant.

Il y a donc quelques temps déjà; j'ai décidé de m'éviter ces peines lors de la mise au point des plugins ou thèmes. J'ai donc opté pour l'approche feignasse.

Comme pour le cas des templates, par exemple^[2], je nomme mes méthodes de classe du même nom que la balise résultante (au préfixe tpl près, bien entendu), je me suis dit que la réflexion disponible en PHP5 allait être mon amie.

Je me suis donc bâti une petite trousse à outils que j'utilise dans les premières étapes d'un développement. Dans cette trousse, j'ai de quoi m'épargner les séances de $core->tpl->addBlock/addValue(...), $core->addBehavior(...), et autres sections répétitives de code sans réelle valeur.

J'en livre ici un petit exemple^[3] :

class datk
{
	public static function registerTemplates($classname)
	{
		global $core;
		
		if (trim($classname) == '') {
			throw new Exception('Aucun nom de classe.');
		}
		
		$class = new ReflectionClass($classname);
				
		if ($class->isAbstract()) {
			throw new Exception('Classe abstraite : '.$classname);
		}

		$methods = $class->getMethods();
		foreach ($methods as $method)	{
			if ($method->isPublic() && $method->isStatic()) {
				$parameters = $method->getParameters();
				if ($nb_parameters = count($parameters)) {
					$name = $method->getName();
					if ($nb_parameters == 1) {
						$core->tpl->addValue($name,array($classname,$name));
					}
					elseif ($nb_parameters == 2) {
						$core->tpl->addBlock($name,array($classname,$name));
					} 
				}
			}
		}
	}
}

Je me retrouve alors à faire un simple appel^[4] :

datk::registerTemplates('maClasseTemplate');

en lieu et place d'un litanie exténuante, et terreau fertile pour mes défauts, de $core->tpl->addMachin().

C'est bête et sans aucun doute inutile pour bon nombre d'entre vous. Mais vous n'avez pas idée du nombre de poignées de minutes que ça m'épargne !

Notes

[1] Dans le meilleur des cas...

[2] Puisque je fais de plus en plus souvent la même chose avec les behaviors.

[3] Frelaté, tout de même : j'ai regroupé dans cet exemple plusieurs méthodes que j'utilise véritablement. Ah ben, oui, par endroit, chez moi, ça génère vraiment le code... :-)

[4] Quel menteur, ce type ! Il faut bien gérer l'inclusion du machin quelque part, hein...

Quick and Dirty

2009-10-14T12:11:00+02:00

C'est un peu le nouveau mode de publication que j'ai envie de mettre en place par ici.

C'est, d'ailleurs, un peu ce que j'ai commencé à faire avec les deux misérables billets publiés en septembre :

En gros, ne plus hésiter à publier des notes dans un mode un peu brut de décoffrage et parfois encore à compléter.

C'est plus particulièrement vrai avec le premier lien, puisqu'il s'agit véritablement d'une bidouille avant tout destinée à faire des tests ou à prototyper des bouts d'échanges par Ajax.

Je ne pense pas qu'un tel morceau de code serve un jour à un utilisateur final. Mais étant donné que ce code là existe et me sert, j'estime qu'il est partageable, m'asseyant alors sur la quête d'un code élégant et/ou optimal.

Si l'idée me plait bien, je dois tout de même avouer n'avoir aucune connaissance des attentes des quelques lecteurs de Bricoland Drive. Je me dis qu'en signalant clairement l'état rugueux de certaines notes, cela ne devrait pas poser problème à la plupart d'entre vous : vous saurez trier le bon grain de l'ivraie.

Mais qu'en est-il vraiment ?

Quand on aime, on ne compte pas ?

2009-09-16T19:14:00+02:00

Même si je veux bien accorder crédit à cet adage, il peut tout de même être - parfois - bien utile de compter.

D'ailleurs, avez-vous remarqué que le jeu de balises pour templates que Dotclear 2.x embarque par défaut ne dispose pas d'un compteur d'entrées générique ?

En cas de besoin, il suffit de recourir à :

quelques séances de copier/coller^[1],
une tournée d'élagage,
une poignée d'enrobage.

On se retrouve alors en présence d'une nouvelle balise {{tpl:EntriesCount}} permettant de retourner le nombre d'entrées en fonction du contexte d'utilisation ou des filtres retenus. Ces fameux filtres étant pour la plupart les options que vous connaissez déjà pour la balise de bloc <tpl:Entries>, vous devriez vite trouver vos marques.

Voici donc de quoi compléter votre trousseau moreTpl.

NB :
A consommer avec modération : cet extrait de code n'a pas été testé très rigoureusement. Prenez donc le temps de le mettre en œuvre sur votre espace de développement avant de songer à le passer en production^[2].

EDIT 21/09/2009 :
~~Dans le doute, et afin de gérer l'absence de contexte, une poignée de @ a été parsemée sur le code existant afin de limiter le risque de levée de NOTICE.~~

Le copier/coller, c'est vraiment mal : voici donc une version plus saine.^[3]

Notes

[1] Oui, c'est mal. :-)

[2] Mais cette remarque reste valable également pour tout nouveau code, même prétendument testé. N'est-ce pas ?

[3] Il va tout de même falloir que je pense à remettre les mains dans YASH tellement le résultat est discutable.

class myLovelyTemplates
{
        public static function EntriesCount($attr)
        {
                $p = "if (!is_array(\$params)) \$params = array();
";

                if (isset($attr['author'])) {
                        $p .= "\$params['user_id'] = '".addslashes($attr['author'])."';
";
                }

                if (isset($attr['category'])) {
                        $p .= "\$params['cat_url'] = '".addslashes($attr['category'])."';
";
                        $p .= "context::categoryPostParam(\$params);
";
                }

                if (isset($attr['no_category'])) {
                        $p .= "\$params['sql'] .= ' AND P.cat_id IS NULL ';
";
                        $p .= "unset(\$params['cat_url']);
";
                }

                if (!empty($attr['type'])) {
                        $p .= "\$params['post_type'] = preg_split('/\s*,\s*/','".addslashes($attr['type'])."',-1,PREG_SPLIT_NO_EMPTY);
";
                }

                if (isset($attr['tag'])) {
                        $p .= 
                                "\$params['from'] .= ', '.\$core->prefix.'meta META ';
".
                                "\$params['sql'] .= 'AND META.post_id = P.post_id ';
".
                                "\$params['sql'] .= \"AND META.meta_type = 'tag' \";
".
                                "\$params['sql'] .= \"AND META.meta_id = '".$GLOBALS['core']->con->escape($attr['tag'])."' \";
";
                }

                if (empty($attr['no_context'])) {
                        $p .=
                                'if ($_ctx->exists("users")) { '.
                                        "\$params['user_id'] = \$_ctx->users->user_id; ".
                                "}
";

                        $p .=
                                'if ($_ctx->exists("categories")) { '.
                                        "\$params['cat_id'] = \$_ctx->categories->cat_id; ".
                                "}
";

                        $p .=
                                'if ($_ctx->exists("archives")) { '.
                                        "\$params['post_year'] = \$_ctx->archives->year(); ".
                                        "\$params['post_month'] = \$_ctx->archives->month(); ".
                                        "unset(\$params['limit']); ".
                                "}
";

                        $p .=
                                'if ($_ctx->exists("langs")) { '.
                                        "\$params['post_lang'] = \$_ctx->langs->post_lang; ".
                                "}
";

                        $p .=
                                'if (isset($_search)) { '.
                                        "\$params['search'] = \$_search; ".
                                "}
";

                        $p .=
                                'if ($_ctx->exists("meta")) { '.
                                        "\$params['from'] .= ', '.\$core->prefix.'meta META ';
".
                                        "\$params['sql'] .= 'AND META.post_id = P.post_id ';
".
                                        "\$params['sql'] .= \"AND META.meta_type = 'tag' \";
".
                                        "\$params['sql'] .= \"AND META.meta_id = '\".\$core->con->escape(\$_ctx->meta->meta_id).\"' \";
".
                                "}
";
                }

                if (isset($attr['selected'])) {
                        $p .= "\$params['post_selected'] = ".(integer) (boolean) $attr['selected'].";";
                }

                return
                        "<?php
".
                        $p.
                        '$_ctx->post_params = $params;'."
".
                        '$_ctx->posts = $core->blog->getPosts($params,true); unset($params);'."
".
                        'echo $_ctx->posts->f(0);'."
".
                        '$_ctx->posts = null; $_ctx->post_params = null;'."
".
                        "?>
";
        }
}

$core->tpl->addValue('EntriesCount',array('myLovelyTemplates','EntriesCount'));

Petite méthode utilitaire pour convertir un recordset en XML

2009-09-16T16:25:00+02:00

Ça vaut ce que ça vaut, et ce n'était pas l'élégance qui primait lors de l'écriture de cette mini-classe mono-méthode.

Vous me pardonnerez donc, je l'espère, l'aspect un rien brut de décoffrage de la solution, mais je pense qu'il peut être intéressant de la partager telle quelle. Pas de documentation non plus, cet embryon de code devrait parler de lui-même.

N'hésitez pas à me faire part de vos améliorations.

class rsUtils
{
	/**
	 * Create a XML chunk from a standard record object.
	 *
	 * @param		record	A standard record object (Cf. Clearbricks dbLayer)
	 * @param		array 	An array of properties to exclude from the dump (default to an empty array)
	 * @return	        string	A string containing the XML chunk.
	 *
	 */
	public static function recordsetToXML($rs,$exclude = array())
	{
		if (!$rs || !$rs instanceof record) {
			throw new Exception(__('Not a valid record object'));
		}
		
		$columns = $rs->columns();
		if (is_array($exclude)) {
			$columns = array_diff($columns,$exclude);
		}
		
		$xml = "<recordset>
";
		while ($rs->fetch()) {
			$xml .= "<record>
";
			foreach ($columns as $col) {
				$xml .= sprintf('<%1$s><![CDATA[%2$s]]></%1$s>'."
",$col,$rs->f($col));
			}
			$xml .= "</record>
";
		}
		$xml .= "</recordset>
";
		return $xml;
	}
}

Plugin dayMode 1.0

2009-03-31T15:06:00+02:00

Le temps de la release est (enfin) arrivé : à compter de ce jour, le plugin dayMode se voit attribuer l'appellation stable.

Pour l'occasion, le code source et le support de cette branche seront désormais hébergés sur Dotclear Lab, comme je l'ai récemment signalé.

Cela signifie que tout détenteur d'un compte Dotclear pourra ainsi :

ouvrir des tickets au sujet de ce plugin, soit pour signaler un bug, soit faire des demandes d'évolutions mineures,
compléter la documentation sur la page wiki dédiée.

Modifications

Les changements apportés dans cette version sont :

Le passage à une licence GNU/GPL v2, strictement.
L'activation du mode d'archives journalières se fait désormais depuis le panneau des Paramètres du blog, et non plus depuis une page d'administration spécifique.
Le fichier template spécifique aux archives journalières, default-templates/archive_day.html a été mis à niveau pour prendre en compte les évolutions apparues dans le thème par défaut de Dotclear 2.1 (balises meta pour les robots, ajout des marqueurs Dublin Core, etc.).
La classe CSS du <body> devient .dc-archive-day et remplace ainsi l'ancienne classe .dc-archive-month.
Le niveau de permission nécessaire à l'activation des archives journalières - et la gestion du widget calendrier qui lui est associé - est l'administrateur de blog et non plus le super-administrateur.
Les types de billets sont maintenant correctement filtrés : les pages, entrées de galeries ou pages related ne sont plus prises en compte lors de la détermination des entrées journalières.

Téléchargement

Pour le téléchargement, merci de passer par la fiche correspondante sur DotAddict.org.

Inventaire et réorganisation des stocks

2009-03-27T17:31:00+01:00

Voilà un moment que le fil de news de Bricoland Drive n'avait pas clignoté. Comme quoi, il ne faut jamais désespérer : tout finit par arriver, même le plus improbable. :-)

Passé le choc de ce non-événement, lançons-nous dans l'explication plein texte du titre.

L'inventaire

Il est grand temps que je prenne le temps de faire le tour des morceaux épars de code, afin de séparer le bon grain de l'ivraie, de virer ce qui n'a plus vraiment lieu d'être, de repérer ce qui manque et pourrait avoir une place convenable dans cette section.

Ce n'est pas une tâche trop pénible. Un peu ingrate, soit. Mais pas pénible. Plus que tout, elle est nécessaire pour le bon déroulement des étapes à suivre.

Actuellement, le Trac attenant au Bricoland Drive n'a que très peu de visibilité et présente une utilité toute relative, puisque m'étant personnelle. Sous le Trac, le SVN^[1] et là, on trouve deux zones bien distinctes du côté des plugins pour Dotclear 2 : une branche current et une branche trunk. Sans plus d'explication, la situation n'est pas bien claire de l'extérieur.

Dans les faits, current contient les sources de versions diffusées officiellement^[2], alors que trunk contient les sources de versions expérimentales ou d'extensions en cours de devenir, normalement distribuées un peu sous le manteau directement par ici.

Réorganisation des stocks

Puisque vous suivez (ou consultez) ce blog, j'en déduis que vous portez un certain intérêt aux plugins pour Dotclear. Aussi n'avez vous pu louper l'annonce en toute fin d'année 2008 de l'ouverture d'un incubateur officiel : Dotclear Lab.

J'ai donc décidé de déplacer peu à peu les versions considérées comme stables de mes plugins vers ce nouveau service. Le déménagement se fera donc plugin après plugin, en profitant de l'occasion pour renuméroter toutes les versions de 0.x en 1.0 après dépoussiérage.

Le premier plugin concerné sera dayMode, qui est passé cette semaine dans les tuyaux du Dotclear Lab. D'autres suivront, tranquillement, dans les semaines qui viennent.

J'utiliserai donc le Lab pour y héberger et assurer le support des extensions que je diffuse officiellement. Il s'agira d'une branche de maintenance destinée à la correction de bugs ou l'ajout de fonctionnalités mineures exclusivement.

Concernant les modifications et/ou les évolutions plus importantes, cela se passera toujours dans ma propre cuisine, qui sera liftée et réaménagée pour l'occasion. D'ailleurs, il est fort probable que cette cuisine passera en accès restreint, et sera réservée à quelques habitués et beta-testeurs privilégiés.

D'ores et déjà, vous pouvez noter en gros quelque part que les adresses pointant vers le(s) Trac(s) actuels de Bricoland Drive disparaitront très rapidement.

Mais encore ?

Cette réorganisation du fond de commerce pourrait bien s'accompagner d'une nouvelle décoration pour la boutique elle-même.

Il est vrai que cette dernière n'est pas particulièrement pratique à parcourir^[3], et il serait dommage de ne pas capitaliser sur la meilleure répartition entre stable et expérimental qu'apportera le cloisonnement entre Dotclear Lab et le Trac d'ici-bas.

Mais là, c'est une autre histoire et, comme souvent, m'avancer sur ce sujet me parait beaucoup trop prématuré. ;-)

Notes

[1] Et non la plage !

[2] Généralement par le biais du référentiel de plugins de DotAddict.org.

[3] N'est-ce pas, brol ?

Chronique d'une mort annoncée

2008-12-18T16:19:00+01:00

S'il était évident pour quiconque que ça ne bougeait plus trop du côté des plugins pour Dotclear 1.x, il manquait toutefois une confirmation officielle. Alors là voici :

Avec l'arrêt programmé du support de la branche 1.x du projet Dotclear, il en sera de même pour les plugins Dotclear 1.x que je mettais à disposition jusqu'à maintenant.

Il faut bien que je reconnaisse que l'aspect Dotclear 1.x n'a jamais vraiment eu droit au chapitre sur le Bricoland Drive. Ce ne sera donc une surprise pour personne.

En résumé

Aucune nouvelle version de ces plugins ne verra le jour.
Le seul support assuré pour ces derniers, jusqu'à la mort définitive de Dotclear 1.x, portera sur la correction d'éventuels problèmes de sécurité.
Les liens de téléchargements actuellement présents disparaitront et la section Plugins pour Dotclear 1 sur DotAddict.org deviendra le seul lieu pour récupérer ces plugins.

Je pense que cette décision ne pénalisera pas grand monde.

Plugin Sitemaps 1.0-RC2

2008-11-05T16:40:00+01:00

C'est l'heure du dépoussiérage pour le plugin Sitemaps.

Au programme :

Correction de la gestion des settings. Les versions précédentes péchaient par approximation, entrainant parfois des effets de bord étranges sur des installations multiblogs.
Possibilité de faire figurer les liens vers les pages tag. Au même titre que pour les catégories, je pense que ce n'est pas forcément une bonne idée de faire figurer ces entrées dans un sitemap.xml. Néanmoins, la demande est là et ce choix revient maintenant à chacun.
Avec l'introduction récente des services Webmasters respectifs de Yahoo! et Microsoft Live Search, il est désormais possible de pinguer autre chose que le seul service de Google.
L'interface d'administration a légèrement été revue, principalement pour intégrer proprement les nouvelles préférences pour la notification par ping.

Cette version a été développée et testée exclusivement sur un Dotclear 2.1, mais devrait fonctionner sans souci avec tout Dotclear 2.0 et supérieur.

En l'état, cette RC2 devrait rapidement se transformer en version finale, sauf bug(s) majeur(s). Je préfère tout de même lui laisser le temps d'une tournée de tests par vos soins, vous les fidèles du Bricoland Drive, avant d'effectuer la mise à jour sur DotAddict.org.

L'archive ZIP est disponible ici.

Juste comme ça, en passant ...

2008-11-03T17:59:00+01:00

Pour ceux qui auraient encore besoin d'installer des plugins disponibles uniquement au format PKG.GZ sur des releases récentes de Dotclear 2.x , vous trouverez désormais dans un sombre recoin de ces lieux un convertisseur PKG.GZ vers ZIP.

C'est de l'archi-minimaliste, sans garantie, mais ça pourrait en dépanner quelques uns.

Les thèmes hérités dans Dotclear 2.1 : un rapide aperçu.

2008-10-23T20:02:00+02:00

Parmi les nouveautés qui seront introduites lors de la sortie de Dotclear 2.1 figure une première ébauche d'un système d'héritage entre thèmes.

Pour l'instant, la présentation de cette fonctionnalité a été plutôt sommaire :

Un thème va pouvoir hériter des templates et des éventuelles balises supplémentaires d'un autre. Si vous avez besoin de dériver un thème pour n'en changer que le style, vous pourrez maintenant le faire sans avoir à recopier tous les templates du premier.

Maintenant que nous ne sommes plus qu'à une grosse semaine de la sortie de la nouvelle version de Dotclear, il me semble bon de prendre un peu de temps pour revenir sur le sujet.

Au moins en attendant que le commando pédagogique de Dotclear nous ponde une documentation digne de ce nom... ;-)

Posons d'abord le décor

Que nous ne nous mèprenions pas : l'idée de thèmes hérités n'est pas nouvelle et encore moins révolutionnaire.

De fait, il s'agit simplement de décliner un nouveau thème depuis un thème existant, sans avoir à tout réécrire ou copier, surtout en matière de templates et de comportements. Pour la suite de ce billet, nous établirons les termes suivants :

Le thème enfant : il s'agit de notre nouveau thème, qui reposera sur une grosse part d'existant fournie par un autre thème.
Le thème parent : c'est ce fameux thème qui nous fournit déjà une base solide que nous nous contenterons de compléter et/ou de spécialiser dans notre nouveau thème enfant.

Si vous avez déjà créé des thèmes pour Dotclear 2, vous devez déjà comprendre pourquoi l'idée des thèmes hérités n'est pas nouvelle.

Non ? Allons... Relisez bien les deux petites définitions.

Et oui : en standard, un thème Dotclear 2 hérite systématiquement du thème default. Rappelez-vous que si votre thème ne fournit pas des versions spécifiques des templates home.html, post.html, category.html, etc. , Dotclear 2 utilisera alors les versions de ces fichiers présentes dans le thème default pour effectuer un rendu des pages.

En résumé : actuellement, tout thème personnalisé est déjà un thème enfant du thème par défaut de Dotclear 2.

La nouveauté dans Dotclear 2.1 tient qu'il sera désormais possible de préciser explicitement et librement cette relation parent/enfant. Vous pourrez alors dire que votre nouveau thème B hérite du thème A, plutôt que du thème default.

Comment les choses s'emboitent

Ou, plus exactement, comment elles s'enchainent.

Séquence de chargement du thème B

Si le thème A fournit un fichier _public.php, ce dernier est chargé.
Ensuite, si le thème B fournit lui aussi un fichier _public.php, celui-ci est chargé à son tour.

Ainsi, si :

de nouvelles balises de templates,
de nouveaux gestionnaires d'URL

ont été définis et sont utilisés dans le thème A, ils seront également directement disponibles dans le thème B.

Ordre de recherche d'un fichier template lors du rendu

Si B dispose du fichier demandé, ce dernier sera utilisé.
Sinon, si A dispose du fichier demandé, celui de A servira au rendu.
Sinon, Dotclear 2.1.x fera la recherche habituelle :
1. d'abord dans le thème par défaut (default),
2. puis dans les autres chemins possibles susceptibles d'avoir été ajoutés par des plugins.

Autres fichiers de thème (CSS, Javascript, images ...)

A l'heure actuelle, aucune notion d'héritage n'est disponible à ce niveau. En tout cas, pas en standard.

Ce qui signifie que tout marqueur {{tpl:BlogThemeURL}} pointera systématiquement vers l'URL de B, même si ce dernier n'apparait que dans un template fourni par A.

Limitation à un - et un seul - niveau d'héritage

Autant vous avertir tout de suite : le système d'héritage des thèmes est volontairement bridé à un seul niveau et un seul lien de parenté.

Sachez donc que :

Un thème ne peut hériter que d'un autre thème et un seul^[1].
Un thème ne peut pas hériter d'un thème qui lui-même hérite d'un autre thème^[2].

Comment ça s'utilise

J'imagine - j'espère - que c'est la dernière question que vous vous posez. :-)

Déclarer explicitement un thème B comme enfant d'un thème A est très simple. Il faudra simplement bien se mettre en tête que la relation entre deux thèmes s'expriment en utilisant les identifiants internes (en gros les noms des dossiers), et non leurs noms communs (aka les libellés).

Tout se passe alors dans le fichier _define.php du thème enfant :

$this->registerModule(
        /* Name */                      "Mon superbe thème",
        /* Description*/                "Exemple d'un thème enfant basé sur Blue Silence",
        /* Author */                    "Pep",
        /* Version */                   '1.0',
        /* Id du Parent */              'blueSilence'
);

Notes

[1] Pas d'héritage multiple, comme on dit dans certaines contrées malfamées.

[2] Enfin, rien dans Dotclear 2.1 ne vous empêchera d'en tenter l'expérience, mais vous serez forcément déçu du résultat. :-)

Template personnalisé par catégorie : au tour des billets

2008-10-17T17:03:00+02:00

J'avais abordé, il y a déjà quelques temps, cette histoire de template personnalisé par catégorie. Mais à l'époque, je m'étais contenté de fournir un moyen d'utiliser un balisage XHTML différent pour la partie liste.

En travaillant sur le prochain habillage de Bricoland Drive, je me suis rendu compte que j'avais besoin d'aller au-delà : j'aimerais bien pouvoir jouer sur la structure des billets rattachés à une catégorie donnée. Pourquoi s'en priver puisque le principe est le même, et que ça se fait en 2 coups de cuillères à pot.

Encore une fois, il n'y a absolument rien de sorcier là dedans. Mais comme j'ai reçu aujourd'hui même une demande par mail portant sur cet aspect là, autant laisser une trace publique.

Reprenons donc le chemin de ce cher fichier _public.php, présent dans notre thème depuis l'épisode précédent.

Tout ce que nous avons à faire, c'est de lui ajouter la prise en charge du mode post.

On commence donc par y placer l'interception des URLs correspondant à ce mode, en faisant pointer la réponse vers la méthode personnalisée que nous fournirons tout de suite après :

$core->url->register('post','post','^post/(.+)$', array('myURLHandlers','post'));

Nous ajoutons maintenant la nouvelle méthode post() dans notre classe myURLHandlers, une fois de plus en ayant recours à un vilain copier/coller depuis le fichier dotclear/inc/public/lib.urlhandlers.php. Et nous n'en modifierons que l'essentiel, c'est-à-dire la partie finale destinée à appeler le rendu du template.

Le code d'origine :

# The entry
self::serveDocument('post.html');
exit;

n'aura qu'à faire place à celui-ci :

# The entry
$tpl = 'post.html';
if ($_ctx->posts->cat_id) {
	$alt_tpl = 'post-cat'.strtolower($_ctx->posts->cat_id).'.html';
	if ($core->tpl->getFilePath($alt_tpl)) {
		$tpl = $alt_tpl;
	}
}
self::serveDocument($tpl);
exit;

Voilà. Nous y sommes. Ou presque... :-)

Presque parce que maintenant que Dotclear 2 nous permet une jolie prévisualisation in situ d'un billet en cours de rédaction, il pourrait être sympa que cette dernière prenne en compte notre modification. Une fois encore, l'ajout de ce petit raffinement sera réglé par copier/coller (* sic *) .

Au final, notre nouveau _public.php hérite de cette tête :

<?php
if (!defined('DC_RC_PATH')) die;
$core->url->register('category','category','^category/(.+)$',array('myURLHandlers','category'));
$core->url->register('post','post','^post/(.+)$',array('myURLHandlers','post'));
$core->url->register('preview','preview','^preview/(.+)$',array('myURLHandlers','preview'));

class myURLHandlers extends dcUrlHandlers
{
	public static function category($args)
	{
		$_ctx =& $GLOBALS['_ctx'];
		$core =& $GLOBALS['core'];
		
		$n = self::getPageNumber($args);
		
		if ($args == '' && !$n) {
			self::p404();
		}
		
		$params['cat_url'] = $args;
		$params['post_type'] = 'post';
		
		$_ctx->categories = $core->blog->getCategories($params);
		
		if ($_ctx->categories->isEmpty()) {
			self::p404();
		} else {
			if ($n) {
				$GLOBALS['_page_number'] = $n;
			}
			$tpl = 'category-'.$_ctx->categories->cat_id.'.html';
			if (!$core->tpl->getFilePath($tpl)) {
				$tpl = 'category.html';
			}
			self::serveDocument($tpl);
			exit;
		}
	}
	
	public static function post($args)
	{
		if ($args == '') {
			self::p404();
		}
		
		$_ctx =& $GLOBALS['_ctx'];
		$core =& $GLOBALS['core'];
		
		$core->blog->withoutPassword(false);
		
		$params = new ArrayObject();
		$params['post_url'] = $args;
		
		$_ctx->posts = $core->blog->getPosts($params);
		
		$_ctx->comment_preview = new ArrayObject();
		$_ctx->comment_preview['content'] = '';
		$_ctx->comment_preview['rawcontent'] = '';
		$_ctx->comment_preview['name'] = '';
		$_ctx->comment_preview['mail'] = '';
		$_ctx->comment_preview['site'] = '';
		$_ctx->comment_preview['preview'] = false;
		$_ctx->comment_preview['remember'] = false;
		
		$core->blog->withoutPassword(true);
		
		
		if ($_ctx->posts->isEmpty())
		{
			# No entry
			self::p404();
		}
		
		$post_id = $_ctx->posts->post_id;
		$post_password = $_ctx->posts->post_password;
		
		# Password protected entry
		if ($post_password != '')
		{
			# Get passwords cookie
			if (isset($_COOKIE['dc_passwd'])) {
				$pwd_cookie = unserialize($_COOKIE['dc_passwd']);
			} else {
				$pwd_cookie = array();
			}
			
			# Check for match
			if ((!empty($_POST['password']) && $_POST['password'] == $post_password)
			|| (isset($pwd_cookie[$post_id]) && $pwd_cookie[$post_id] == $post_password))
			{
				$pwd_cookie[$post_id] = $post_password;
				setcookie('dc_passwd',serialize($pwd_cookie),0,'/');
			}
			else
			{
				self::serveDocument('password-form.html','text/html',false);
				exit;
			}
		}
		
		$post_comment =
			isset($_POST['c_name']) && isset($_POST['c_mail']) &&
			isset($_POST['c_site']) && isset($_POST['c_content']) &&
			$_ctx->posts->commentsActive();
		
		# Posting a comment
		if ($post_comment)
		{
			# Spam trap
			if (!empty($_POST['f_mail'])) {
				http::head(412,'Precondition Failed');
				header('Content-Type: text/plain');
				echo "So Long, and Thanks For All the Fish";
				exit;
			}
			
			$name = $_POST['c_name'];
			$mail = $_POST['c_mail'];
			$site = $_POST['c_site'];
			$content = $_POST['c_content'];
			$preview = !empty($_POST['preview']);
			
			if ($content != '')
			{
				if ($core->blog->settings->wiki_comments) {
					$core->initWikiComment();
				} else {
					$core->initWikiSimpleComment();
				}
				$content = $core->wikiTransform($content);
				$content = $core->HTMLfilter($content);
			}
			
			$_ctx->comment_preview['content'] = $content;
			$_ctx->comment_preview['rawcontent'] = $_POST['c_content'];
			$_ctx->comment_preview['name'] = $name;
			$_ctx->comment_preview['mail'] = $mail;
			$_ctx->comment_preview['site'] = $site;
			
			if ($preview)
			{
				$_ctx->comment_preview['preview'] = true;
			}
			else
			{
				# Post the comment
				$cur = $core->con->openCursor($core->prefix.'comment');
				$cur->comment_author = $name;
				$cur->comment_site = html::clean($site);
				$cur->comment_email = html::clean($mail);
				$cur->comment_content = $content;
				$cur->post_id = $_ctx->posts->post_id;
				$cur->comment_status = $core->blog->settings->comments_pub ? 1 : -1;
				$cur->comment_ip = http::realIP();
				
				$redir = $_ctx->posts->getURL();
				$redir .= strpos($redir,'?') !== false ? '&' : '?';
				
				try
				{
					if (!text::isEmail($cur->comment_email)) {
						throw new Exception(__('You must provide a valid email address.'));
					}

					# --BEHAVIOR-- publicBeforeCommentCreate
					$core->callBehavior('publicBeforeCommentCreate',$cur);
					if ($cur->post_id) {					
						$comment_id = $core->blog->addComment($cur);
					
						# --BEHAVIOR-- publicAfterCommentCreate
						$core->callBehavior('publicAfterCommentCreate',$cur,$comment_id);
					}
					
					if ($cur->comment_status == 1) {
						$redir_arg = 'pub=1';
					} else {
						$redir_arg = 'pub=0';
					}
					
					header('Location: '.$redir.$redir_arg);
					exit;
				}
				catch (Exception $e)
				{
					$_ctx->form_error = $e->getMessage();
					$_ctx->form_error;
				}
			}
		}
		
		# The entry
		$tpl = 'post.html';
		if ($_ctx->posts->cat_id) {
			$alt_tpl = 'post-cat'.strtolower($_ctx->posts->cat_id).'.html';
			if ($core->tpl->getFilePath($alt_tpl)) {
				$tpl = $alt_tpl;
			}
		}
		self::serveDocument($tpl);
		exit;
	}
	
	public static function preview($args)
	{
		$core = $GLOBALS['core'];
		if (!preg_match('#^(.+?)/([0-9a-z]{40})/(.+?)$#',$args,$m)) {
			self::p404();
		}
		$user_id = $m[1];
		$user_key = $m[2];
		$post_url = $m[3];
		if (!$core->auth->checkUser($user_id,null,$user_key)) {
			self::p404();
		}
		
		self::post($post_url);
		exit;
	}
}
?>

Ainsi, pour effectuer le rendu d'un billet :

Nous regardons d'abord si le billet appartient à une catégorie
Si c'est le cas, nous demandons à Dotclear 2 de nous dire si un fichier template nommé post-cat##.html existe (où ## représente l'identifiant numérique de la catégorie).
Si Dotclear 2 nous répond positivement, c'est ce template là qui sera rendu.
Dans tous les autres cas, nous continuerons à servir un post.html.

Une fois de plus, c'est un jeu d'enfant.

Néanmoins, les plus pointilleux d'entre vous auront remarqué une chose flagrante : cette solution n'est pas élégante, puisqu'elle impose de recourir à de vilains copier/coller. Nous sommes donc bien loin du principe DRY^[1], et sommes peut-être bien en face d'une faiblesse de conception de ce côté là de Dotclear 2.

Mais là, c'est une autre histoire et le Bricoland Drive n'est sans doute pas le lieu le plus approprié. ;-)

Notes

[1] Pour les moins pointilleux - mais néanmoins curieux - d'entre vous, reportez-vous à : http://en.wikipedia.org/wiki/DRY_code.

La nouvelle version de dc1redirect est arrivée

2008-09-05T02:23:00+02:00

... mais, comme prévu et annoncé précédemment, elle se trouve de nouveau dans le giron dotclear.net. C'est désormais là-bas que vous pourrez en suivre l'évolution.

Olivier vient donc de signer une release 1.0 de ce petit plugin, en vue de compléter le nécessaire pour les migrations de Dotclear 1.x à Dotclear 2.0.x. Au passage, l'incompatibilité avec le plugin alias, qui avait été relevée par Julien, n'est plus.

Les liens et informations encore présents par ici concernant cette extension seront mis à jour en conséquence.

Arrivée surprise d'un petit nouveau : feedEntries

2008-09-01T15:04:00+02:00

Voici un petit plugin tout simple, tout bête qui ne figurait pas dans mon programme de ces jours, mais qui s'y est invité par la force des choses.

Comme j'ai rencontré ce besoin sur un projet personnel, j'ai dû me bricoler le nécessaire pour pouvoir disposer de balises templates afin de présenter - en dehors du simple widget Lecteur de nouvelles de Dotclear2 - le contenu d'un flux externe.^[1]

En résumé :

Ce petit plugin n'a aucune interface d'administration et ne nécessite aucune configuration particulière.
Toute la partie récupération et analyse du flux externe repose sur des classes déjà fournies par Dotclear2 : aucune librairie supplémentaire n'est donc nécessaire.
Le jeu de balises fourni est disponible dans n'importe quel contexte (home, post, etc.).
On peut intégrer plusieurs flux dans une même page, mais ils devront chacun disposer de leur propre boucle de traitement : ce plugin n'a rien à voir avec un agrégateur de type Planet.
Pour l'instant, la seule documentation se résume aux quelques commentaires présents dans le fichier _public.php.
Je pense déjà à l'ajout d'une nouvelle fonctionnalité qui pourrait être bien utile, mais je préfère pour l'instant me contenter de valider l'essentiel.

Pour les pré-requis, vous commencez à connaitre la musique : c'est pour du Dotclear 2.0.x.
Si vous êtes intéressé, il ne vous reste plus qu'à télécharger le ZIP (version 1.0-RC1 (4 Ko)).

Vos retours seront les bienvenus.

Notes

[1] Pour ceux qui auraient un peu de mal à voir de quoi je parle, il s'agit grosso merdo d'un équivalent de ce qui existait pour Dotclear 1.x et connu en tant que RSS Reader.