aNieto2K Desarrollo web, Wordpress, y alguna cosilla más

En DigWP hacen una recopilación altamente recomendable sobre trucos de configuración para WordPress, aunque ya vimos hace un tiempo todas las opciones del fichero wp-config.php, estas harán que le saque más partido a tu WordPress.

Se trata de una traducción de lo que me ha parecido interesante de este artículo de DigWP.com.

Secure Keys

Estas keys se encargan de añadir un grado de seguridad a nuestro WordPress haciendo que la encriptación de la cookie sea más robusta y difícil de descifrar. El equipo de WordPress pone a nuestra disposición una url donde generar estas keys aleatoriamente, simplemente tendremos que copiarlas en nuestro fichero wp-config.php.

define('AUTH_KEY',        '|@@ozJobZd8P#n*qU&U`+d2^-zFJ|u0cJub3>w,N,rk>u#7s|*[=E b1t_A?$W>P');
define('SECURE_AUTH_KEY', '4KN-v/#,txKyv.<#H|>#1az_d6!jHtgv:?ZGmn)9iJESSsr[AWH@d31=hIOU}l,*');
define('LOGGED_IN_KEY',   '+uVyb{2b~`@z3hI+^h?*p1esJb ]Itx6+Nh~C|wA4Hyo @eL|-iL.6-+Bju/.$B(');
define('NONCE_KEY',       'L%H|GLc_CfOOtZZ*1zL=|o-tQnX$b[_iWL8_.-*|/Jl4t n,#;;gw.%!+*=|B!5>');

Prefijo de la base de datos

La personalización de WordPress va desde el aspecto hasta la BD. Una muestra de ello, es la posibilidad de personalizar el prefijo de la base de datos con el que será más difícil conocer el nombre de las tablas por aquellos usuarios malintencionados.

$table_prefix  = 'wp_';

Dirección del blog y el theme

Desde WordPress 2.2 tenemos la posibilidad de especificar la URL del blog directamente desde el fichero wp-config.php. Esto, permite omitir los datos almacenados en la base de datos referentes a la ubicación del blog y recoja la dirección del fichero wp-config.php.

define('WP_HOME', 'http://www.anieto2k.com');
define('WP_SITEURL', 'http://www.anieto2k.com.com');

Para el theme también tenemos un par de variables globales que podemos usar para almacenar las direcciones del theme y la hoja de estilos.

define('TEMPLATEPATH', get_template_directory());
define('STYLESHEETPATH', get_stylesheet_directory());

Activar/Desactiva la wp-cache

La wp-cache, es la caché interna de WordPress y esta, como ya vimos hace tiempo, se trata de un conjunto de funciones que permite que gestionemos datos cacheados en nuestros plugins/themes.

Desde wp-config.php podemos especificar si esta caché está activada o no, y el tiempo de vida de los datos en caché.

// Activar
define('WP_CACHE', true);      // enable the cache
define('ENABLE_CACHE', true);  // enable the cache
define('CACHE_EXPIRATION_TIME', 3600); // in seconds
// Desactivar
define('WP_CACHE', false);     // disable the cache
define('DISABLE_CACHE', true); // disable the cache

Personalizar las tablas user y user_meta

Si queremos compartir tablas de usuarios entre diferentes blog, o añadir un grado más de seguridad cambiando los nombres de la tablas de usuarios y de user_meta directamente desde el fichero wp-config.php.

define('CUSTOM_USER_TABLE', $table_prefix.'my_users');
define('CUSTOM_USER_META_TABLE', $table_prefix.'my_usermeta');

Especificar datos de acceso FTP

Los datos de acceso FTP nos permiten actualizar plugins directamente desde el panel de administrador, definir estos datos puede ayudarnos a que nuestros usuarios no tengan que introducir los datos a la hora de actualizar los plugins.

define('FS_METHOD', 'ftpext'); // forces the filesystem method: "direct", "ssh", "ftpext", or "ftpsockets"
define('FTP_BASE', '/path/to/wordpress/'); // absolute path to root installation directory
define('FTP_CONTENT_DIR', '/path/to/wordpress/wp-content/'); // absolute path to "wp-content" directory
define('FTP_PLUGIN_DIR ', '/path/to/wordpress/wp-content/plugins/'); // absolute path to "wp-plugins" directory
define('FTP_PUBKEY', '/home/username/.ssh/id_rsa.pub'); // absolute path to your SSH public key
define('FTP_PRIVKEY', '/home/username/.ssh/id_rsa'); // absolute path to your SSH private key
define('FTP_USER', 'username'); // either your FTP or SSH username
define('FTP_PASS', 'password'); // password for FTP_USER username
define('FTP_HOST', 'ftp.domain.tld:21'); // hostname:port combo for your SSH/FTP server

Especificar el tiempo de autosalvado

Una de las utilidades que más desapercibido han pasado y que más están ayudando a los usuarios de WordPress, es el auto salvado de posts mientras escribimos. Desde wp-config.php podemos especificar el intervalo de tiempo en los que se han de auto salvar los posts.

define('AUTOSAVE_INTERVAL', 160); // in seconds

Log de peticiones a la BD

Si eres un amante de los logs y del control, esta configuración te permitirá hacer que las peticiones a la base de datos sean almacenadas para visualizarlas posteriormente. Para ello debemos indicarlo en el fichero wp-config.php

define('SAVEQUERIES', true);

Y después modificar el theme para hacer que estas peticiones sean visibles para los administradores.

// Mostramos las peticiones solo para administradores
if (current_user_can('level_10')) {
	global $wpdb;
	echo "<pre>";
	print_r($wpdb->queries);
	echo "</pre>";
}

Control de acceso

Imagina que tienes un WordPress montado dentro de una intranet, y no quieres permitir el acceso desde servidores externos a ella, con wp-config.php (desde WordPress 2.8) esto es posible mediante unas simples líneas.

define('WP_HTTP_BLOCK_EXTERNAL', true);  // block external requests
define('WP_HTTP_BLOCK_EXTERNAL', false); // allow external requests

Además podemos filtrar mucho más aún, permitiendo que ciertos PC’s tengan acceso al blog.

define('WP_ACCESSIBLE_HOSTS', 'api.wordpress.org'); // whitelist hosts

Los elementos <table />, poco a poco, se están usando para lo que fueron creados, como la mejor forma de mostrar datos tabulados al usuario. Gracias a este uso, es posible usar javascript para añadirle funcionalidad a esas estáticas tablas.

(Ver Imagen)

Entre estos 15 plugins jQuery, seguro que encuentras algo para hacer que tus tablas de datos no sean planas y sin opciones.

DataTables

Permite:

• Edición al vuelo
• Carga de datos con Ajax
• Paginación
• Multiordenación por columnas
• Extensible por plugins
• Personalizable por CSS
• Idiomatizable

uiTableFilter

Permite:

• Filtrar datos al vuelo

Scrollable HTML Table

Permite:

• Usar la estructura HTML
• Limitar el alto y ancho de la tabla

Tablesorter

Permite:

• Multiordenación por columnas
• Extensible mediante widgets

Flexigrid

Permite:

• Re-dimensionar las columnas
• Re-dimensionar la tabla
• Ordenación por columnas
• Carga de datos mediante Ajax
• Paginación
• Mostrar u Ocultar columnas
• Toolbar inferior con opciones
• Busqueda de datos
• API accesible

HeatColor

Permite:

• Establecer rango de colores para visualizar más fácilmente resultados.

JQTreeTable

Permite:

• Mostrar datos en forma de arbol dentro de tu tabla.

Ingrid

Permite:

• Re-dimensionar columnas
• Paginación
• Ordenación por columna o fila
• Personalización mediante CSS

jQuery ColumnManager plugin

Permite:

• Mostrar u ocultar columnas.

jQuery treeTable

Permite:

• Mostrar datos en forma de árbol.

CSV2Table

Permite:

• Cargar datos de un fichero CSV

Table Pagination

Permite:

• Paginación

jQuery TableRowCheckboxToggle

Permite:

• Cambiar la class de la fila mediante checkboxes (para remarcarlas)

Table Drag and Drop jQuery plugin

Permite:

• Hacer Drag and Drop en filas reordenandolas.

uiTableEdit

Permite:

• Permite editar la tabla por el usuario

Hace unas semanas tuve que implementar una Class para cachear elementos de mi PHP en ficheros estáticos. Inicialmente usé un sistema similar al que había usado siempre basado en la función filemtime() que me devolvía la fecha de modificación del archivo estático y la contrastaba con la actual, si el resultado era mayor a un número de segundos especificado volvía a generar el fichero estático.

Código filemtime()

class Cache {
 function fileName($key){
 return 'cache/'.md5($key);
 }

 function put($key, $datos){
 $f = fopen($this->fileName($key), 'w');
 if (!$f) die('No se puede leer el fichero de caché');

 $data = serialize($data);

 if (fwrite($f,$data)===false) {
 die('No se puede escribir el fichero de caché');
 }
 fclose($f);
 }

 function get($key){
 $filename = $this->fileName($key);
 if (!file_exists($filename) || !is_readable($filename)) return false;
 if ((filemtime($filename) + 3600) < time()) {
 return file_get_contents($filename);
 }
 return false;
 }
}

Esta versión, me permite cachear en fichero cualquier contenido que yo le indique mediante put(). Veamos un ejemplo.

$cache = new Cache();
if (!$data = $cache->get('misdatos')) {
 ....
 $cache->put('misdatos', $misdatos);
}

Problemas

Tras unas horas usándolo me encontré con un problema, la poca flexibilidad de este sistema. Necesitaba que ciertos datos, se cachearan una hora y otros lo hicieran 24. De esta forma me era dificil montar un sistema basado en filemtime() que me permitiera indicar una caché para tiempos diferentes.

Las soluciones pasaba por comprobar el tipo de contenido y dependiendo de que fuera tomar un tiempo u otro, o crear métodos específicos para cachear por tiempos (put60(), put24(),…). Ninguna solución me parecía elegante.

Serialize()

Entonce recordé un artículo de hace ya unos años en los que mediante el uso de serialize() permitía hacer lo que estaba buscando.

serialize() es una función de PHP que permite convertir un objeto que puede ser fácilmente almacenable. Algo que me venía ideal para hacer que mi caché de ficheros estática fuera más flexible.

Código serialize()

>class Cache {
 var $cacheDir;

 function __construct($cacheDir = './'){
 $this->cacheDir = $cacheDir;
 }

 // Indicamos el directorio donde queremos alojar los ficheros de caché
 function put( $key , $data ,$time = 600) {

 $h = fopen( $this->getFileName( $key ) , 'w' );
 if (!$h) throw new Error('No se puede leer el fichero de caché');

 $data = serialize( array( time() + $time , $data ) );

 if ( fwrite( $h , $data ) === false ) {
 throw new Error('No se puede escribir el fichero de caché');
 }
 fclose($h);

 }

 // Obtenemos el nombre del fichero codificado
 private function getFileName($key) {
 return  $this->cacheDir.md5($key);
 }

 // Recuperamos de caché
 function get($key) {

 $filename = $this->getFileName($key);
 if (!file_exists($filename) || !is_readable($filename)) return false;

 $data = file_get_contents($filename);

 $data = @unserialize($data);
 if (!$data) {
 unlink($filename);
 return false;
 }
 if (time() > $data[0]) {
 unlink($filename);
 return false;
 }
 return $data[1];
 }
}

Esta clase ya me permite especificiar de una forma cómoda el tiempo que quiero que se cachee un contenido determinado.

$cache = new Cache('cache/');
if (!$data = $cache->get('misdatos')) {
 ....
 $cache->put('misdatos', $misdatos, 60); // 60 seg
}

Rendimiento

Este sistema es muy cómodo, pero hay que ser conscientes de los problemas de rendimiento que presenta. Hemos de pensar que cada comprobación pasa por leer el contenido del fichero, convertir el objeto serializado y comprobar la fecha de este último.

Esto, frente a la simple consulta de la última fecha de modificación hace que este método sea considerablemente más lento. Pero por contra es bastante más flexible.

Mejoras

Bueno, despues de todo el rollo os propongo un juego. ¿Como lo podemos mejorar?

Mi opción

La opción que estaba barajando era la de generar un fichero con la fecha de caducidad del fichero y el nombre del fichero. De esta forma, únicamente tendría que hacer una lectura de fichero para cargar la fecha de caducidad asociada al fichero y despues mediante filemtime() comprobar si esta es superior a la especificada.

Ejemplo

<?php
...

// Leer
$content = file_get_content($file);
$times = unserialize($content);

 if (filemtime($cache_file) > $times[$cache_file]) {
 ....
 // Generamos de nuevo la caché
 $times[$cache_file] = time() + 60; // 60 seg.
 }

// Grabar
serialize(array(
 md5("tmp".time()).".cache" => '123456789'
 ....
));

...
?>

¿Alguna idea más?

Jose Luis Antunez, me avisa por email de la publicación de YouAre Theme, un theme que han desarrollado con la idea de ofrecer la misma cantidad de opciones de configuración que los themes de pago.

(Ver Imagen)

Opciones y más opciones

Entre las opciones que nos podemos encontrar vale la pena destacar, la integración con Twitter, Flickr, Google Analytics o FeedBurner, además de la posibilidad de cambiar fácilmente los colores del theme.

(Ver Imagen)

A nivel técnico nos encontramos con:

• Basado en el Framework CSS 960.gs concretamente en el model de 24 colúmnas.
• Valida según los estándares XHTML.
• Optimizado para SEO
• Multi-Lenguaje (dependiendo del idioma especificado en wp-config.php).
• Gravatar integrado
• Comentarios anidados
• Microformatos
• Mejoras de accesibilidad

Demo y Descarga

Demo y Descarga

James Padolsey publica un interesante script que, como el mismo dice, es realmente obstructivo puede ser interesante conocer la idea y ver sus posibilidades.

// HTML
<div id="some-div">
   <script type=":contextual">
      alert(this.id); // "some-div" is alerted
   </script>
</div>

// Javascript
(function(){

   var scripts = document.getElementsByTagName('script'),
   script, i = 0;

   while ( (script = scripts[i++]) ) {
     if ( /:contextual$/.test(script.type) ) {
        (new Function(script.innerHTML)).call(script.parentNode);
     }
   }

})();

A simple vista, vemos un tag <script type=":contextual" /> y una función javascript que se encarga de recorrer los elementos <script /> y generar una nueva función con el contenido de lo :contextual. Esto ejecuta el contenido los <script type=":contextual" /> con el código que haya dentro de ellos.

La utilidad es que nos permite usar un javascript “contextual”, y si nos fijamos en el ejemplo anterior, el alert(this.id); nos mostrará el ID del <div /> superior, incluyendo el contexto en el que se encuentre el tag.

Una interesante idea que reaprovecha los tags <script /> al igual que hacíamos hace unos meses.