Seulement voilà, lors de toute tentative de mise à jour, que ce soit du blog, d’une extension ou d’un thème, un écran de configuration de paramètres FTP apparaît. Comme nous sommes des feignants, on ne voudra en aucun cas ouvrir un serveur FTP, qui n’aurait d’ailleurs pour d’autre intérêt que de faciliter les intrusions dans votre système.

Où trouver l’information ?

En cherchant un peu, je suis tombé sur l’ensemble des directives de configuration de WordPress, dont les constantes liées au système de fichier.
Cette section précise ce qu’il faut savoir, même si c’est suffisamment technique pour perdre toute personne ne comprenant rien au code (et on ne leur en voudra pas).

Le problème vient du fait que si l’utilisateur propriétaire du système de fichier n’est pas le même utilisateur du serveur HTTP, WordPress bascule automatiquement en mise à jour via FTP.

L’astuce consiste à forcer WordPress en mode direct (système de fichier) et à donner les droits d’écriture au groupe propriétaire correspondant à celui du serveur HTTP (www-data pour Apache et Nginx sous Debian et Ubuntu).

Configuration de wp-config.php

Forcer le mode direct est très simple. Il suffit d’éditer le fichier wp-config.php, celui-là même qui contient les identifiants de connexion à la base de données et autres joyeusetés. Et d’y rajouter cette ligne, avant la première directive par exemple :

define('FS_METHOD', 'direct');

Enregistrez, et c’est plié.

Réglage des permissions

Côté permissions, ça peut également se régler en 2 coups de terminal. Partons du principe que le groupe propriétaire de votre serveur HTTP est www-data, à la base de votre installation WordPress, il suffit de faire ceci :

chgrp -R www-data wp-content/upgrade wp-content/themes wp-content/plugins wp-content/uploads
chmod g+wx wp-content/upgrade wp-content/themes wp-content/plugins wp-content/uploads

Cette manipulation attribue www-data comme propriétaire des répertoires que vous souhaitez rendre accessibles en écriture et ce, de manière récursive. Dans un second temps, elle attribute les droits d’écriture et d’exécution au groupe propriétaire (peu importe le nom du groupe).
Si vous êtes perdu(e) avec la commande chmod, un peu de lecture pour apprendre à le manipuler (ça sauve la vie).

Conclusion

A ce stade des choses, tout est fonctionnel : tentez d’installer une nouvelle extension, ça passera comme une lettre à la poste.
Si vous rencontrez des difficultés, c’est très certainement parce que les permissions des fichiers qui tentent d’être modifiées ne sont pas suffisantes pour le groupe propriétaire du serveur HTTP. Ajustez la procédure des permissions par rapport à votre besoin.

C’est pas sorcier, il suffisait de le savoir  :-)

J’ai récemment lu une astuce pour afficher sa blogroll sur une page à part et ça m’a donné envie de réagir à la solution proposée.

Gérer sa blogroll sur une page dédiée est une bonne idée car ça évite de surcharger inutilement ses barres latérales de liens, surtout s’ils sont nombreux. Cette séparation permet également d’avoir davantage de liberté pour les présenter et les styler. Ce n’est pas un mal pour apporter un souffle d’originalité.

En revanche la solution du copié/collé n’est pas à mes yeux une véritable solution car :

• soit on gère sa blogroll dans le module de blogroll et on doit systématiquement copier/coller le résultat dans une page
• soit on gère directement la blogroll dans la page dédiée ; le module de gestion perdant alors totalement son intérêt

Je suis feignant donc je n’aime pas faire le travail 2 fois alors je propose une solution qui fonctionnera chez vous. C’est d’ailleurs celle que j’emploie depuis la refonte de ce blog … c’est à dire bientôt 1 an.

Les modèles de page WordPress

Il existe peu de différences entre une page et un article dans WordPress :

• les articles sont datés, n’ont pas de hiérarchie et peuvent être dans 1 ou plusieurs catégories
• les pages ne le sont pas datées, ont une hiérarchie et ne peuvent pas être dans une catégorie

Les pages possèdent également un autre atout : on peut leur appliquer un modèle de présentation. Cette pratique est adaptée à toute présentation où vous souhaiteriez afficher davantage que le seul texte saisi depuis l’interface d’administration.

La notion des templates de pages est bien expliquée dans le Codex WordPress. Petit rappel synthétique néanmoins.

Un template de page correspond à un fichier créé dans le répertoire du thème de votre choix (celui que vous utilisez de préférence). Autrement dit ça correspond à un fichier comme ceci : wp-content/themes/<votre thème>/<votre template>.php.

Ce fichier de template doit obligatoirement comporter une entête de description. Sans elle, pas de sélection possible depuis la page de rédaction. Cette entête doit correspondre à ceci :

<?php
/*
Template Name: <Nom du template>
*/

La dernière étape avant son utilisation consiste à tapoter un peu de code PHP pour aboutir à votre souhait. N’hésitez pas à parcourir la documentation de WordPress pour produire un code pérenne et utiliser au maximum les fonctionnalités proposées par WordPress.

Un modèle de page WordPress pour Blogroll

Notre besoin initial tombe à point nommé puisque nous avons justement besoin d’un template de page pour gérer sa blogroll depuis son module d’administration sans avoir à mettre à jour manuellement quelconque autre page que ce soit

La première étape consiste à créer un nouveau template dans le thème employé par votre blog. Si vous utilisez le thème de base, le thème default, nous allons créer le fichier suivant :
wp-content/themes/default/template-blogroll.php.

Pour remplir ce fichier, nous allons devoir accéder aux éléments contenus dans la blogroll. Ça tombe bien puisqu’il existe pour ça la fonction wp_list_bookmarks().
À ce stade, notre template devrait ressembler à ça :

<?php
/*
Template Name: Liens
*/
get_header() ?>
<h2><?php the_title() ?></h2>
<?php the_content() ?>
<ol id="page-blogroll">
  <?php wp_list_bookmarks() ?>
</ol>
<?php get_sidebar() ?>
<?php get_footer() ?>

Une fois enregistré, le modèle apparaît dans le sélecteur de modèle (uniquement sur les contenus de type Page) :

Ça y’est, vous avez votre page dédiée aux liens sans travail de recopie supplémentaire.

Un modèle imparfait

Attention toutefois puisque créer un modèle signifie que WordPress ne va utiliser QUE ce modèle pour la présentation. Autrement dit il va falloir toute reproduire jusqu’au titre de la page si vous le désirez.

L’exemple ci-dessus est minimaliste à ce sujet pour la simple et bonne raison que le balisage dépendra uniquement du thème employé. Ça explique pourquoi les modèles sont à définir au cas par cas.

Pour bien reproduire le thème, plusieurs possibilités :

• vous vous débrouillez vous-même pour comprendre comment est construit l’affichage du thème
• vous connaissez quelqu’un qui se débrouille avec WordPress et vous lui demandez de le faire (pas la peine de me demander)

Conclusion

Les modèles de page (ou templates) est une fonctionnalité assez méconnue mais pourtant ô combien utile pour les utilisations suivantes :

• utilisation tournée CMS
• affichage différent pour certaines pages uniquement, sans vouloir créer un thème spécifique
• création de pages plus riches allant au-delà de la simple présentation de contenu rédigé

Si vous vous débrouillez bien, vous aurez un résultat comme sur ma page de liens, les liens de l’Oncle Tom.
Et n’oubliez pas, dès que vous pensez « spécifique », pensez modèle de page

Si l’on en croit la recherche Google Internet Explorer ne peut pas afficher cette page Web, il semblerait que pas mal de monde soit concerné par un facheux problème. Internet Explorer 7 affiche sur certains site cette page d’erreur sans raison évidente. Ca en a même causé sur les groupes de discussions Microsoft.

Alerté par un client par l’expression sibylline votre site a plein de bugs (c’était le seul), j’ai décidé de perdre une heure à trouver une solution au problème. Préparez vos favoris, j’ai trouvé la solution !

Il existe en fait 3 solutions :

1. revenir à Internet Explorer 6 (ceux qui ont Vista pourront se brosser, vous pouvez aussi revenir à Windows XP)
2. utiliser un véritable navigateur Web, gratuit et plus sûr : Firefox ou Opera (je ne recommanderai pas Safari pour l’instant, trop instable)
3. changer un réglage d’Internet Explorer 7 et attention, c’est du lourd !

En cliquant sur Outils > Options Internet > Avancés, descendez au niveau de Paramètres HTTP 1.1. Décochez tout, validez et quittez le navigateur (même si rien ne vous indique de le faire). Relancez Internet Explorer 7 et comme par magie, toutes les pages inaccessibles ne le sont plus !

Reste maintenant à élucider pourquoi l’interprétation du protocole HTTP 1.1 pose problème uniquement sur certaines pages.

Ca peut sembler inutile à première vue lorsqu’on utilise MySQL au travers d’API d’autres langages (PHP, Perl, C# etc.). Et pourtant ça peut vous être très utile pour économiser des requêtes, du temps à programmer ces boucles et puis surtout, par flemme.

Oui, la flemme est pour moi la qualité numéro un du développeur car le flemmard a pour but d’arriver à ses fins en un minimum d’efforts.

Déclaration de variables

On peut déclarer une variable de deux façons dans MySQL.
La première méthode consiste à utiliser l’opérateur SET.

SET @pierre = 3, @feuille = 3 + 2, @ciseau = @pierre % @feuille ;

On peut également consister une variable à partir d’une requête.

SELECT @nb_total := COUNT(*) FROM `ma_table` ;

Note : dans ce cas là, on préfixe l’opérateur = de : (deux points).

Utilisation simple des variables

L’utilisation première qui peut en être faite c’est d’assainir vos requêtes SQL en évitant au maximum l’apparition de variables issues d’autres langages.
Avant :

SELECT * FROM `ma_table` WHERE colonne1 = {$variable1}, colonne2 = '{$variable2}' LIMIT 1;

Après :

SET @variable1 = {$variable1}, @variable2 = '{$variable2}';
SELECT * FROM `ma_table` WHERE colonne1 = @variable1, colonne2 = @variable2 LIMIT 1;

Comme les variables sont effectives pour la connexion courante, une variable MySQL peut être réutilisée à tout moment. De quoi décomplexifier certains scripts pas forcément bien structurés.

Utilisation complexe des variables

Les variables peuvent également être modifiées à même la requête. C’est à dire qu’à chaque itération effectuée par MySQL, le moteur va réévaluer le contenu de la variable. J’ai notamment eu besoin de ça pour ajouter de nouveaux éléments à la suite d’autres tout en renumérotant leur ordre. Je souhaitais éviter une boucle récursive en PHP qui aurait occasionné de multiples requêtes.

Je dispose d’une table (item_liste) avec plusieurs éléments, une clé primaire sur deux champs (item_id et item_cat) ainsi qu’un autre champ indexé permettant de les trier dans un ordre donné (item_ordre). Le but : prendre des éléments de la catégorie 1 pour les mettre à la suite de la catégorie 2.

Voici en gros ce que ça donne au final :

SELECT @ordre := IFNULL(MAX(item_ordre), 0) FROM `item_liste` WHERE item_cat = 2 ;
UPDATE `item_liste` SET item_ordre = @ordre := @ordre+1, item_cat = 2 WHERE item_cat = 1 ;

1. On compte la borne supérieure de la catégorie 2. Pourquoi un IFNULL ? Parce MAX() retournera NULL si un des item_ordre en contient un. C’est une sécurité ;
2. On met à jour les éléments de la catégorie 1 avec leur nouvel ordonnancement et leur nouvelle catégorie.

Alors pourquoi ça fonctionne ? La commande UPDATE balaie les lignes une par une et du coup, met à jour la variable @ordre à chaque ligne. Nous retrouvons ainsi l’effet désiré : incrémenter chaque ligne déplacée dans la nouvelle catégorie.

Il existe des utilisations plus compliquées que celles-là mais je pense que c’est un bon départ pour se faire une idée de ce qui est faisable par ce biais là. L’imagination et les besoins feront le reste

Il existe deux solutions pour la rotation de vos images :

1. activer la rotation automatique de l’appareil photo (si celui-ci la propose). Personnellement je n’aime pas cette option à cause des bordures noires ajoutées à la photo ;
2. effectuer soi-même la rotation de la photo pour qu’elle se présente telle qu’on l’a prise.

L’inconvénient de cette dernière méthode est qu’il faut appliquer une rotation à chaque image, dans le bon sens. Une opération qui devient rapidement fastidieuse.
Depuis sa version 2.16 (il me semble), le logiciel de visualisation d’images gThumb sous Linux propose deux outils sympathiques de rotation automatique d’images. Un énorme gain de temps.

Pré-requis

Le seul pré-requis à ces outils de feignants est que votre appareil photo numérique enregistre l’orientation de la prise de vue. Je pense que tous les appareils doivent le faire car déjà en 2000 c’était le cas. Si ce n’est pas le cas, vous avez sûrement choisi un appareil plus que bas de gamme et retournés ou pas, les clichés ne sont pas vraiment exploitables.

Rotation automatique à l’import

Comme l’illustre la capture d’écran ci-dessus, l’assistant d’import d’images de gThumb propose une option Pivoter physiquement l’image. Lors de l’import des photos depuis le medium en question, gThumb pivotera les images dans le bon sens. Du coup il n’y a plus rien à faire si ce n’est regarder les photos sans avoir à pencher la tête sur le côté pour admirer les photos de mémé.

Rotation automatique sur une sélection d’images

Pas de chance pour vous, mémé vous a refilé un CD entier d’images qui n’ont pas été pivotées. Vous souffrez d’avance rien qu’à l’idée de pivoter les images une par une mais par chance, gThumb est encore là grâce à un outil utilisable à tout moment.
Lorsque gThumb est lancé et que vous parcourez un répertoire rempli de photos à pivoter, sélectionnez-les toutes (Control + A pour faire vite) et activez le menu Outils > Pivoter les images. En cochant ensuite les cases Appliquer à toutes les images et Appliquer les transformations physiques, gThumb passera au crible toutes les photos sélectionnées et les pivotera automatiquement dans le bon sens, peu importe l’orientation d’origine.

gThumb est un outil particulièrement bien conçu pour les manipulations d’images. D’ailleurs je regrette qu’il ait été délaissé dans GNOME au profit de F-Spot. Ce dernier est en revanche plus agréable à utiliser pour la visualisation de photos, surtout grâce à son système de chronologie.

Et généralement on se confronte au problème du cache des navigateurs Web. Ces derniers conservent en mémoire les feuilles de style pendant un certain temps causant ainsi un décalage entre le fichier CSS du serveur (et la présentation souhaitée) et celui du navigateur (reposant sur une présentation obsolète).

Inclure une feuille de style

L’inclusion d’une feuille de style au sein même de la page n’est pas une opération qui devrait vous poser trop de problèmes. Elle peut se faire de deux façons, la première étant compatible avec tous les navigateurs, la seconde seulement avec les navigateurs modernes.

/* inclusion "old school" */
<link rel="stylesheet" type="text/css" href="url/style.css" media="screen" />
/* inclusion "moderne" */
<style type="text/css">@import url('url/style.css') screen;</style>

Inclure une feuille de style avec mise à jour automatique

Vous allez voir, c’est tout bête. On reprend l’exemple précédent ; on veut conserver le même nom de fichier mais il a été mis à jour et on souhaite que le navigateur le recharge sans que l’utilisateur ait à faire un petit F5 sur son clavier.

/* inclusion "old school" */
<link rel="stylesheet" type="text/css" href="url/style.css?v=1234" media="screen" />
/* inclusion "moderne" */
<style type="text/css">@import url('url/style.css?v=1234') screen;</style>

Vous voyez le v=1234 ? Le fait d’ajouter un paramètre au fichier appelé dupe le navigateur et lui fait croire qu’il s’agit d’un fichier différent de style.css. En réalité on peut mettre n’importe quoi en paramètre (le timestamp de mise à jour du fichier par exemple. Par exemple style.css?1180077252).

Pourquoi ça fonctionne ?

Dans une URI, le chemin physique du fichier s’arrête juste avant le ?. Tout ce qui est inscrit après est considéré comme étant des paramètres, compléments virtuels du-dit fichier. Ce qui importe au navigateur, c’est que le fichier en question renvoie bien des données dans le type MIME attendu, ici text/css.

Le navigateur gère le cache d’un fichier par rapport à son adresse complète, ceci incluant les paramètres fournis. Pour lui, style.css?v=1 et style.css?v=2 sont deux fichiers différents, peu importe s’il s’agit en réalité du fichier style.css.
En cas de changement de paramètre, le navigateur estime qu’il s’agit d’un nouveau fichier, récupère celui-ci et, magie, utilise la dernière version en date de celui-ci plutôt qu’une version en cache, obsolète.

Cette petite astuce permet de gagner en crédibilité face à des clients, évite aux internautes d’être perdus dans un affichage incohérent misant fortement sur les feuilles de style.
Exactement ce que l’on recherchait

Sélection optimisée avec IN()

IN() devrait être utilisé dès lors que l’on a plusieurs critères sur un même colonne. L’écriture suivante ne devrait pas apparaitre dans votre code :

SELECT * FROM `ma_table` WHERE id = 3 OR id = 5;

A la place, il devrait y avoir ceci :

SELECT * FROM `ma_table` WHERE id IN (3, 5);

C’est une habitude à prendre car elle permettra d’automatiser bien des choses. Imaginez qu’on ne fasse plus cette sélection « en dur » mais à partir d’un tableau PHP. Trois façons d’écrire la requête, vous verrez vite laquelle sera la plus pratique à réutiliser :

$tableau = array(3, 5);
/* Méthode 1 : vite-fait mal fait */
$separateur = '';
$sql = "SELECT * FROM `ma_table` WHERE ";
foreach( $tableau as $id )
{
	$sql .= $separateur." id = ".$id;
	$separateur = ' OR ';
}
/* Méthode 2 : utilisation "optimisée" avec des OR dans la requête */
$sql = "SELECT * FROM `ma_table` WHERE id = ".implode(' OR id = ', $tableau);
/* Méthode 3 : passe-partout */
$sql = "SELECT * FROM `ma_table` WHERE id IN (".implode(',', $tableau).")";

Le gros avantage de la dernière méthode c’est le retraitement des données. Il est facile et plus logique d’imploser et d’exploser une chaine composée de séparateurs virgule (ou autre caractère employé aux mêmes fins).

$tableau = array(3, 5);
$tableau = implode(',', $tableau);
/* du code nécessitant $tableau en tant que chaîne */
$tableau = explode(',', $tableau);
/* du code nécessitant $tableau en tant que tableau */

Aggrégats avec GROUP_CONCAT()

Dans les exemples précédents, $tableau était rempli « en dur ». Dans la vraie vie, ça ne se passe pas comme ça : on récupère des identifiants (clés et/ou index) pour valider les sélections. L’exemple basique : on veut mettre à jour une table de configuration avec les ID d’articles présents dans une ou plusieurs catégories.

$tableau = array();
/* Sélection des ID */
$query = mysql_query("SELECT id FROM `ma_table` WHERE cat_id IN ('fromage', 'tortues');");
while( $ligne = mysql_fetch_assoc($query) )
{
	$tableau[] = $ligne['id'];
}
/* On met à jour notre table de configuration */
$tableau = implode(',', $tableau);
mysql_query("REPLACE INTO `table_config` (config_id, config_valeur) ".
	"('cache_articles', '{$tableau}')");

C’est simple, propre et on se dit qu’on a bien bossé. Et pourtant, l’utilisation de la fonction d’agrégation GROUP_CONCAT() de MySQL nous épargnera quelques lignes. On appréciera :

$tableau = array();
/* Sélection des ID */
$query = mysql_query("SELECT GROUP_CONCAT(id) AS cache_articles FROM `ma_table` WHERE cat_id IN ('fromage', 'tortues');");
$tableau = mysql_fetch_assoc($query);
/* On met à jour notre table de configuration */
mysql_query("REPLACE INTO `table_config` (config_id, config_valeur) ".
	"('cache_articles', '{$tableau['cache_articles']}'");

Bref, on a gagné une boucle (le while), des lignes de résultats MySQL (autant de ressources d’économisées) et un traitement PHP en moins (implode). Et devinez quoi ? Le résultat retourné par le GROUP_CONCAT s’intègre très bien dans le … IN().

Voyons ensemble 10 combinaisons de touches avec Control, facilement mémorisables. Ces combinaisons se retrouvent sur la plupart des logiciels Windows, Linux et Mac OS X à la différence près que pour ce dernier, c’est la touche Pomme qui interagit.

Sur la première rangée de votre clavier :

• Control + A (All, tous) : sélectionner tout le contenu d’une zone active (document, zone de texte etc.) ;
• Control + Z : annule un changement et revient à l’état précédent. Très pratique dans les éditeurs de texte pour corriger rapidement une phrase ;
• Control + T (Tab, onglet) : crée un nouvel onglet dans les applications gérant ce mécanisme (Firefox, Internet Explorer 7, GAIM etc.) ;

Sur la deuxième rangée de votre clavier :

• Control + Q (Quit, quitter) : ferme entièrement une application ;
• Control + S (Save, sauvegarder) : enregistre le document actif. Indispensable avec les éditeurs de texte ;

Sur la troisième rangée de votre clavier :

• Control + W (Window, fenêtre) : ferme l’onglet actif dans les applications gérant ce mécanisme ;
• Control + X (Cross, Cut, couper) : coupe la sélection (texte, documents) en attendant d’être collée ;
• Control + C (Copy, copier) : copie la sélection (texte, documents) en attendant d’être collée ;
• Control + V : colle la sélection (texte, documents) ;
• Control + N (New, nouveau): crée un nouveau document au sein de l’application (fenêtre, fichier etc.).

Ca peut paraître barbare à première vue et pourtant. Regardez votre clavier : ce sont systématiquement des touches placées en début de rangée et allant vers la droite. Toutes ces combinaisons s’effectuent facilement avec une seule mains et 2 doigts.
Pour faire simple et efficace : appuyez sur la touche Control avec votre auriculaire puis sur son complément avec votre index OU votre majeur pour les touches les plus proches de Control. Ca évite les contorsions inconfortables.

Personnellement je préfère largement abuser du Control + S que faire confiance aux sauvegardes automatiques (surtout quand on connaît la capacité de Microsoft Office à détruire vos fichiers). Vous économisez des clics, votre poignet et du temps tout en gagnant en confort d’utilisation.