La verdad es que una herramienta que nos permita manejar estos ficheros de forma colaborativa y utilizando una interfaz web medianamente intuitiva y fácil de usar era algo que llevaba tiempo necesitando pero que entre pitos y flautas no tenía tiempo de buscar. Conocía la existencia de Launchpad, pero yo pensaba que era sólo para proyectos de software libre por lo que para proyectos cerrados no me valía (ahora me he dado cuenta de que también tiene servicio de pago, aún así siempre prefiero una alternativa open source y que pueda instalar en mis propios servidores). La cuestión, es que sin quererlo, he encontrado la solución cuando hacía otra consulta en la página sobre traducciones de WordPress.

Como habréis podido adivinar por el título de este post la solución que he encontrado se llama Pootle (PO-based Online Translation / Localization Engine) y también es válido para otros tipos de archivo de traducción como pueden ser los XLIFF. Podéis ver en este enlace un versión live de esta aplicación si queréis ver un poco mejor de que se trata, pero si queréis cacharrear un poco más podéis instalarlo directamente en Ubuntu que es bastante sencillito (en otras distribuciones o SO os buscáis la vida :p ). Como casi siempre, hay paquete:

sudo apt-get install pootle

Yo lo he configurado para que use mysql en vez de sqlite3 editando el fichero localsettings.py. Si tú también lo vas a hacer, deberás instalar primero el paquete python-mysqldb, crear una BD para ello, y modificar estos datos en el fichero de configuración (hay otros datos que también puedes modificar ahí, como por ejemplo configurarlo para usar memcached):

sudo apt-get install python-mysqldb
gedit /etc/pootle/localsettings.py

Una vez que tengas todo listo y configurado solo tienes que hacer correr el servidor de Pootle:

sudo PootleServer

Esto lo hará correr por el puerto 8080, si ya tienes algo ahí o prefieres usar otro puerto solo tienes que indicárselo:

sudo PootleServer --port=XXXX

Finalmente, si todo ha ido bien tendrás tu servidor montado. Sino has hecho alguna otra configuración, puedes acceder a él accediendo a la URL: http://127.0.0.1:8080/. Si has seguido estos mismos pasos puedes loguearte con el usuario admin password admin y empezar a toquetear y cambiar configuraciones (cambia también el pass ). Ya os contaré algunas impresiones si finalmente lo implantamos para algún proyecto.

Los que usamos Symfony no tenemos porque volvernos locos para usar Lucene, la API de Google GData, manejar PDFs, recoger feeds o tantas otras funcionalidades que cubre tan bien el Framework Zend. No, porque integrar Zend en Symfony viene a ser bastante sencillo:

Añadir la librería Zend a nuestro código

Debemos descargar el Framework Zend y copiarlo en lib/vendor, que es el directorio donde guardamos habitualmente las librerías externas. Ahí lo meteremos todo dentro de una carpeta nueva que llamaremos Zend.

Sistema para cargar Zend cuando lo necesitemos

Para esto lo que vamos a hacer es crear un método nuevo en la clase config/ProjectConfiguration.class.php que nos permita cargar Zend fácilemente desde cualquier parte:

class ProjectConfiguration extends sfApplicationConfiguration

  static protected $zendAutoloader = false;

  /** ............ **/

  /**
   * Agrega el framework Zend a nuestra App
   */
  static public function registerZend()
  {
    if(!self::$zendAutoloader)
    {
      set_include_path(implode(
        PATH_SEPARATOR,
        array(sfConfig::get('sf_lib_dir') . '/vendor', get_include_path())
      ));
      require_once 'Zend/Loader/Autoloader.php';
      self::$zendAutoloader = Zend_Loader_Autoloader::getInstance();
    }

    return self::$zendAutoloader;
  }
}

Empezamos a usarlo

Una vez hecho todo esto podríamos tranquilamente en un action o en algún task hacer uso del framework Zend. Por ejemplo…

// Cargamos el framework Zend
ProjectConfiguration::registerZend();

// Utilizamos Zend....
try {
  $feed = Zend_Feed_Reader::import($parameters['feed']);
} catch (Zend_Feed_Exception $e) {
  /** ........ **/
}

Como podéis ver eso es todo A continuación os pongo las diapos que pasó la gente de Symfony y Zend en las conferencias explicando la utilidad de integrarlos y donde explican como hacerlo que es de donde he sacado yo la info:

• Using Zend Framework and Symfony Together (Zend PHP Conference 2009)
• Using Zend Framework with Symfony (sfLive 2010)
• Integrating symfony and Zend Framework (IPC 2010)

Por lo general, cuando estoy con un proyecto que necesita un servicio de email suelo recomendar e instalar Google Apps for Business. Me parece que dan un buen servicio y se puede dar de alta facilmente simplemente teniendo el control de los DNS del dominio. Pero a veces, como en este caso, lo que busco es simplemente que el email loquesea@midominio.com sea reenviado a example@gmail.com.

En este ejemplo hablamos de configurarlo en un servidor con Ubuntu y con postfix instalado. Si tienes otra distribución me temo que tendrás que ver por ti mismo como hacerlo de manera equivalente y si tienes Ubuntu pero no tienes postfix instalado lo puedes instalar haciendo simplemente:
sudo apt-get install postfix

Antes de nada haz una copia del fichero de configuración que vamos a modificar por si acaso:
sudo cp /etc/postfix/main.cf /etc/postfix/main.cf.bkp

Luego edita ese fichero y agrega las siguientes líneas (o modificalas si ya tienes esas variables definidas):
virtual_alias_domains = midominio.com
virtual_alias_maps = hash:/etc/postfix/virtual
(Asegurate de que el dominio que agregas como alias no se encuentre en ese mismo fichero en la variable mydestination)

La variable virtual_alias_domains indica en este caso los dominios de los que aceptamos recibir emails para luego reenviarlos, por eso añadimos el dominio del email que queremos reenviar. Por otro las virtual_alias_maps indica el fichero que contiene los alias que vamos a crear para poder reenviar los emails. El fichero está en /etc/postfix/virtual y en nuestro ejemplo debería contener:
loquesea@midominio.com example@gmail.com
fulano@midominio.com otherexample@gmail.com
# Uncomment entry below to implement a catch-all address
# @midominio.com example@gmail.com

Como se puede apreciar primero se debe escribir el alias y después el email al que quieres reenviar; una línea por cada reenvio que queramos configurar. Como se puede apreciar también se puede configurar para tener un catch-all.

Finalmente y para que los cambios que hemos hecho surjan efecto debemos recargar los aliases y reiniciar o recargar el servidor de postfix:
postmap /etc/postfix/virtual
postfix reload

Creo que eso es todo, si véis que falta algo decídmelo en los comentarios.

Hay más información en el propio README de Postfix.

¿Porqué necesitamos los Namespaces?

Según va aumentando el número de librerías escritas en PHP se hace mayor el riesgo de colisión de nombres de clases y funciones entre librerías. En un principio sería totalmente comprensible que diferentes programas implementen por ejemplo una clase llamada Photo que maneje las imágenes en el proyecto, pero eso hasta la llegada de PHP 5.3 estaba mal visto porque había que intentar evitar tener problemas de compatibilidad con otros proyectos. Por eso mismo era más probable que esa clase se llamara por ejemplo Mi_Proyecto_Photo.

Ejemplos de este tipo se pueden ver por ejemplo en WordPress dónde todas las clases empiezan por WP_ o en el framework Zend, donde la política de nombres (muy descriptiva) hace que se le asignen nombres a veces demasiado largos a las funciones: Zend_Search_Lucene_Analysis_Analyzer_Common_Text_CaseInsensitive.

Los Namespaces resuelven este problema porque las constantes, clases y funciones pueden quedar definidas dentro de su Namespace, sin entrar en conflicto con otros homónimos que estén dentro de otros namespaces.

¿Cómo se definen los Namespaces?

Por defecto, y si no se indica lo contrario, todas las funciones, clases y constantes quedarán definidas en el entorno global, como ha sido siempre en PHP. Será lo que pase con todas las librerías que carguemos y que no estén realizadas específicamente para PHP 5.3 o superior, y que por lo tanto no tendrán definido su namespace.

Pero si vamos a correr nuestro programa sobre PHP 5.3 o superior debemos empezar a definir los namespaces en nuestros programas y para ello simplemente hay que hacerlo utilizando la palabra clave namespace seguido del nombre al inicio de nuestro script; siempre debe ser la primera instrucción del fichero sin tener ningún otro código delante, ni espacios, ni HTML (excepto declare):

// Definición del namespace para el código de este script
namespace MiProyecto;
// A partir de aquí escribe tu código y domina el mundo 

Lo lógico y lo recomendado es que utilices un fichero por cada namespace que definas, pero si por alguna extraña razón quisieras hacerlo varias veces en el mismo podrías de la siguiente manera:

// Definición del namespace para el proyecto 1
namespace MiProyecto1;
// Código del Proyecto1
// Definición del namespace para el proyecto 2
namespace MiProyecto2;
// Código del Proyecto2
// Definición del namespace para el proyecto 3 con la sintaxis alternativa
namespace MiProyecto3 {
    // Código del Proyecto3
}

Sub-namespaces:

También podemos definir sub-namespaces para tener mejor estructurado nuestro código, o lo que es lo mismo, organizar jerarquicamente nuestras librerías o programas. Como separador a la hora de definir los namespaces y sus sub-namespaces utilizaremos la barra invertida: \. Ejemplos:

• MiProyecto\DB\MySQL
• MiProyecto\DB\Mongo
• MiProyecto\Contenido\Articulos
• OtraCompania\MiProyecto\Plugin\Comentarios

¿Cómo llamar a elementos que se encuentren dentro de un namespace?

Vamos a tomar como ejemplo la siguiente librería definida bajo el namespace Berriart\Sample y que guardaremos como berriart.sample.php:

<?php
// Código de la sección  Sample del proyecto Berriart
namespace Berriart\Sample;
const MYCONST = 'Berriart\Sample\MYCONST';
function MyFunction() {
    return __FUNCTION__;
}
class MyClass {
    static function WhoAmI() {
        return __METHOD__;
    }
}  

Ahora podríamos incluir este código desde otro script y ejecutarlo de la siguiente manera:

<?php
header('Content-type: text/plain');
require_once('berriart.sample.php');
echo \Berriart\Sample\MYCONST . PHP_EOL;
echo \Berriart\Sample\MyFunction() . PHP_EOL;
echo \Berriart\Sample\MyClass::WhoAmI() . PHP_EOL;

En este pequeño script hacemos uso de la función, la clase y la constante definidas en anterior fichero. Como éste no tiene namespace definido se está ejecutando en el entorno global, y por lo tanto para poder hacer uso de los elementos definidos en un namespace determinado los llamamos en este caso haciendo uso de la ‘ruta absoluta’ del namespace. El anterior código nos devolbería lo siguiente:

Berriart\Sample\MYCONST
Berriart\Sample\MyFunction
Berriart\Sample\MyClass::WhoAmI

Como os podéis imaginar, utilizar el nombre del namespace completo cada vez que llamamos a una función, clase o constante no nos aporta muchos más beneficios que los largos nombres descriptivos, pero no os preocupéis porque no es la única manera de llamarlos, y a continuación podemos ver todas las maneras de hacerlo. Las diferentes nomenclaturas son similares a las de los sistemas de ficheros:

Nombre completamente cualificado (Fully-qualified name) (~ruta absoluta)

Es la manera que hemos visto en el anterior ejemplo y consiste en utilizar el nombre completo del namespace. Para indicar que se trata de un nombre absoluto debemos empezar la llamada con una barra, ej:

$variable = \Berriart\Sample\MyClass::WhoAmI();

De esta manera no hay lugar a ambigüedades. Da igual si este código se encuentra dentro de algún namespace o en el espacio glogal, al estar escrita ‘la ruta completa’ siempre se hará la misma llamada. Pero como se puede apreciar generalmente no sería muy práctico.

Nombre cualificado (Qualified name) (~ruta relativa)

Un identificador con al menos un separador de namespace:

$variable = Sample\MyClass::WhoAmI();

Si el namespace actual fuera Berriart, esto se resolvería con Berriart\Sample\MyClass::WhoAmI():

<?php
namespace Berriart;
header('Content-type: text/plain');
require_once('berriart.sample.php');
echo Sample\MyClass::WhoAmI() . PHP_EOL;

// Devolvería:
// Berriart\Sample\MyClass::WhoAmI

Pero si el código es global, esto se resuelve con Sample\MyClass::WhoAmI() que en el caso del ejemplo al no existir devolvería error:

<?php
header('Content-type: text/plain');
require_once('berriart.sample.php');
echo Sample\MyClass::WhoAmI() . PHP_EOL;

// Devolvería error:
// Fatal error: Class 'Sample\MyClass' not found in...

Nombre no cualificado (Unqualified name) (~fichero relativo)

Nombre de clase, constante o función sin hacer referencia a ningún namespace:

$variable = MyClass::WhoAmI();

Si el código en el que esto se ejecuta es global, no se encuentra en un namespace, esto se resuelve con la clase MyClass que también debería estar definida en el espacio global y no dentro de un namespace. En cambio si la llamásemos dentro de un namespace primero buscaría dentro de ese namespace y luego en el espacio global.

Importando namespaces

Los namespaces se pueden importar mediante el comando use. La utilización del comando use no cambia el espacio en el que trabajamos, si estamos en el espacio global seguiremos en él, y si estamos dentro de un namespace porque estamos usando la palabra clave ‘namespace’ dentro de nuestro script, también seguiremos en él; pero nos permitirá hacer uso de cosas de otros namespaces haciendo uso del nombre cualificado.

<?php
header('Content-type: text/plain');
require_once('berriart.sample.php');

use Berriart\Sample;
echo Sample\MyClass::WhoAmI() . PHP_EOL;

// Devolvería:
// Berriart\Sample\MyClass::WhoAmI

Se pueden importar tantos namespaces como se quieran haciendo uso del comando use en repetidas ocasiones o separandolos con comas en la misma instrucción.

Es importante remarcar que en este ejemplo que hemos puesto seguimos en el espacio global por lo que no se podría llamar directamente a MyClass::WhoAmI() (de manera no cualificada) porque buscaría esa clase también en el espacio global.

Creando Alias para los namespaces

Los alias son un recurso muy útil para poder acortar los nombres de los namespaces a la hora de hacer nuestras llamadas. Se crean utilizando la palabra clave as junto al comando use:

<?php
header('Content-type: text/plain');
require_once('berriart.sample.php');

use Berriart\Sample as BS;
echo BS\MyClass::WhoAmI() . PHP_EOL;

// Devolvería:
// Berriart\Sample\MyClass::WhoAmI

Hay que destacar que también se pueden crear alias directamente para las clases (no en cambio para constantes y funciones):

<?php
header('Content-type: text/plain');
require_once('berriart.sample.php');

use Berriart\Sample\MyClass as Obj;
echo Obj::WhoAmI() . PHP_EOL;

// Devolvería:
// Berriart\Sample\MyClass::WhoAmI

Reglas de resolución de nombres

Las llamadas desde la incorporación de los namespaces se resuelven siguiendo estas reglas:

1. Las llamadas a clases, funciones o constantes completamente cualificadas se resuleven en tiempo de compilación. Por ejemplo new \A\B se resuelve con la clase A\B.
2. Todos los nombres no cualificados y cualificados (no los completamente cualificados) se traducen durante la compilación según las reglas de importación actuales. Por ejemplo, si el espacio de nombres A\B\C se importa como C, una llamada a C\D\e() se traduce a A\B\C\D\e().
3. Dentro de un espacio de nombres, todos los nombres cualificados no traducidos según la reglas de importación tienen añadido al inicio el namespace actual. Por ejemplo, si una llamada a C\D\e() se lleva a cabo dentro del namespace A\B, se traduce a A\B\C\D\e().
4. Los nombres de clases no cualificados se traducen durante la compilación según las reglas de importación actuales (el nombre completo sustituido por el nombre abreviado importado). Por ejemplo, si el espacio de nombres A\B\C se importa como C, new C() se traduce a new A\B\C().
5. Dentro de un espacio de nombres (digamos A\B), las llamdas a funciones no cualificadas se resuelven en tiempo de ejecución. Aquí se muestra cómo se resuelve una llamada a la función foo():
   1. Se busca una función desde el espacio de nombres actual: A\B\foo().
   2. Se intenta encontrar y llamar a la función global foo().
6. Dentro de un namespace (digamos A\B), las llamadas a nombres de clases no cualificados o cualificados (no los completamente cualificados) se resuelven en tiempo de ejecución. Aquí se muestra cómo se resuelve una llamada a new C() o a new D\E().

   Para new C():

   1. Se busca una clase desde el espacio de nombres actual: A\B\C.
   2. Se intenta autocargar A\B\C.

   Para new D\E():

   1. Se busca una clase añadiendo al inicio el espacio de nombres actual: A\B\D\E.
   2. Se intenta autocargar A\B\D\E.

   Para referenciar cualquier clase global en el espacio de nombres global, se debe usar su nombre completamente cualificado new \C().

La constante __NAMESPACE__ y la palabra clave namespace

La constante especial __NAMESPACE__ siempre nos devolverá el namespace actual, en el que nos econtramos. En el caso de estar en el espacio global devolverá una cadena vacia.

<?php
namespace Berriart\Sample;
echo __NAMESPACE__; // devuelve: Berriart\Sample

Esto tiene una clara aplicación para el debugging, pero también nos sirve para hacer llamadas utilizando el nombre totalmente cualificado:

<?php
namespace Berriart\Sample;
class MyClass {
	public function WhoAmI() {
		return __METHOD__;
	}
}
$c = __NAMESPACE__ . '\\MyClass';
$m = new $c;
echo $m->WhoAmI(); // devuelve: Berriart\Sample\MyClass::WhoAmI

En el caso de este ejemplo como la clase a la que queremos llamar se encuentra en el mismo namespace en el que nos encontramos también podríamos referirnos a la clase utilizando la palabra clave namespace, que utilizada así sería el equivalente a la palabra clave self dentro de las clases:

<?php
namespace Berriart\Sample;
class MyClass {
	public function WhoAmI() {
		return __METHOD__;
	}
}
$m = new namespace\MyClass();
echo $m->WhoAmI(); // devuelve: Berriart\Sample\MyClass::WhoAmI

Autoloading de clases usando Namespaces

Una de las más importantes funcionalidades de PHP 5 a la hora de ahorrar tiempo es la carga automática. Antes, en un programa que solo hiciera uso del espacio global una posible definición de la función especial __autoload sería:

<?php
$obj1 = new MyClass1(); // classes/MyClass1.php is auto-loaded
$obj2 = new MyClass2(); // classes/MyClass2.php is auto-loaded
// autoload function
function __autoload($class_name) {
	require_once("classes/$class_name.php");
}

En PHP 5.3, utilizando namespaces, a la función autoload se le pasaría el namespace completo más el nombre de la clase. Por ejemplo, el valor de $class_name podría ser “Berriart\Sample\MyClass”. Por lo tanto, aunque podrías seguir metiendo todas las clases en la misma carpeta y crear una regla de nomenclatura, lo lógico sería que la estructura de ficheros de la librería sea relativa a la estructura de los namespaces y que la función __autoload fuera algo así:

<?php
function __autoload($class_name) {
	// convert namespace to full file path
	$class_path = 'classes/' . str_replace('\\', '/', $class_name) . '.php';
	require_once($class_path);
}

Webgrafía y créditos

Para redacactar este artículo practicamente se ha traducido este tutorial del inglés, y se ha contrastado y completado con el manual de PHP sobre namespaces.

Espero que leer esto os haya ayudado a entender mejor los namespaces, con lo que sea ya sabéis, dejad un comentario.

Si tienes un servidor Ubuntu con Apache y quieres instalarlo a continuación te describo los pasos que he seguido yo para hacerlo (recuerda que si no estás como usuario ‘root’ tendrás que hacer sudo):

Instalar suvbersion:
apt-get install subversion libapache2-svn

Instalar Trac y el módulo de Python para Apache:
apt-get install libapache2-mod-python libapache2-mod-python-doc trac

Crear la carpeta que hará de ‘Document Root’ para poder acceder al trac via web, por ejemplo:
mkdir /var/www/trac

Si lo quieres proteger, como es mi caso, crea un fichero .htpasswd:
htpasswd -c /var/www/trac/.htpasswd admin

Preparar el Virtual Host:
vi /etc/apache2/sites-available/trac

Y escribir:

<VirtualHost *>
ServerAdmin mymail@domain.com
ServerName trac.domain.com

<Location /projects> #set up Trac handling
SetHandler mod_python
PythonHandler trac.web.modpython_frontend
PythonOption TracEnvParentDir /var/www/trac
PythonOption TracUriRoot /projects

#authentication scheme
AuthType Basic
AuthName "My Tracker"
AuthUserFile /var/www/trac/.htpasswd
Require valid-user

</Location>

ErrorLog /var/log/apache2/trac_error.log

# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
LogLevel warn

CustomLog /var/log/apache2/trac_access.log combined

</VirtualHost>

Vamos a crear un repositorio SVN para el código:
mkdir /var/lib/svn
mkdir /var/lib/svn/myproject
svnadmin create /var/lib/svn/myproject

Yo lo he preparado para poder tener diferentes tracs, así que estos pasos se pueden repetir:
mkdir /var/www/trac/myproject
trac-admin /var/www/trac/myproject initenv
sudo chown -R www-data:www-data /var/www/trac/myproject

Finalmente reiniciamos Apache:
/etc/init.d/apache2 restart

Y ya podríamos acceder a nuestro trac en este ejemplo en: http://trac.domain.com/projects

Espero que os sirva de ayuda.

Algunos dirán que lo que digo es una barbaridad, pero me parece una de las mejores herramientas y sobre todo la más ligera. Porque aunque en un principio parezca que es muy light, si sabemos cómo, podemos personalizarla y convertirla en una gran herramienta. Hace tiempo Miquel ya nos dió unos consejitos, pero como se nos ha pasado a Mac, ahora me tengo que buscar la vida :p

Os explico mi configuración y ya me diréis que opináis:

Lo primero es ir a las preferencias (Editar->Preferencias), y adecuaremos unas cuantas cositas:

- Pestaña ‘Ver’:

• Mostrar números de línea
• Resaltar línea actual
• Resaltar pareja del corchete

- Pestaña ‘Editor’:

• Insertar 4 espacios en lugar de tabulaciones
• Activar sangría automática
• Desactivar copia de seguridad, ya que crea archivos con el mismo nombre con el caracter ‘~’ al final, que hace que linux los trate como ocultos y que si los subimos al servidor nos traeran graves problemas de seguridad

Los colores que vienen por defecto para resaltar el código, no me gustan. Yo prefiero el fondo negro, ahorro energia y descanso la vista :p Así que nos vamos a la siguiente pestaña ‘Tipografías y colores’. De los esquemas existentes, tampoco me convencen ninguno, así que lo que hice fue descargarme otro. Aquí podéis descargar colores para Gedit, a mi el esquema que más me gusta y el que uso es el Darkwin. Para instalarlo, descargalo y luego en la pestaña pulsa en el botón ‘Añadir’ y agregalo.

Ahora llega el turno de instalar plugins o complementos para el Gedit. Por defecto trae algunos preinstalados que solo necesitamos activar desde la cuarta pestaña del panel de preferencias. Activaremos los siguientes:

• Herramientas externas – Permite ejecutar comandos o programas externos a Gedit para facilitarnos el trabajo. Más adelante explicaré como configurarlo.
• Panel de examinador de Archivos – Pone a nuestra disposición un panel lateral para examinar y acceder a los archivos de nuestro proyecto (Tecla rápida F9).
• Recortes – Permite insertar ‘recortes’ de código, o estructuras muy utilizadas (loops, ifs,…). Escribe la palabra clave y luego pulsa tabulador, el resto se escribirá solo.
• Sangrar líneas – Permite el sangrado de líneas de manera rápida mediante Ctrl+T.

Además de estos, creo que es una buena opción instalar otro plugin más, pero este no viene por defecto, se llama Symbol Browser. Se trata de un panel lateral que permite la exploración de objetos, funciones, defines,…

Yo os explico como le he instalado en Ubuntu 9.04, pero si necesitáis más información podéis ver este artículo que fue como lo descubrí. Lo primero que hay que hacer es instalar Exuberant Ctags, que es la herramienta ne la que se basa este plugin, luego descargamos el plugin y lo instalamos. No olvides después de instalarlo activarlo en la pestaña ‘Complementos’ como hemos hecho con los anteriores.

sudo apt-get install ctags
cd ~/.gnome2/gedit/
wget http://sourceforge.net/projects/symbol-browser/files/symbol-browser-bin/gedit-symbol-browser-plugin-bin-ubuntu-i386-0.1/gedit-symbol-browser-plugin-bin-ubuntu-i386-0.1.tar.gz/download #La URL puede cambiar al cambiar de versión
tar -xzf gedit-symbol-browser-plugin-bin-ubuntu-i386-0.1.tar.gz

Eso sería todo. Bueno, más bien casi todo. Por último habría que configurar el plugin ‘Herramientas externas’ para poder realizar diferentes tareas, como comprobar la syntaxis de nuestro código, consultar la documentación de PHP, ‘standarizar’ nuestro código con el programa PHP-Beautifer,… Para ver como hacerlo creo que lo mejor es que os paséis por la web de la que he recogido la mayor parte de la info que he puesto en este post, ya que mejor que él seguro que no lo explico: Micah Carrick

Para ello WordPress nos ofrece dos funciones que nos permitirán que se ejecute algo al activar o desactivar un plugin, estas funciones son register_activation_hook y register_deactivation_hook. Se puede ver su modo de empleo en las siguientes líneas de código que simulan la situación que he expuesto antes:

<?php

register_activation_hook( __FILE__, 'plugin_name_activate' );
register_deactivation_hook( __FILE__, 'plugin_name_deactivate' );

function plugin_name_activate() {
	global $wpdb;
	$sql = 'CREATE TABLE `' . $wpdb->prefix . 'plugin_name`
		( `id` INT( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
		`date` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ,
		`otro` VARCHAR( 255 ) NOT NULL )
	';
	$wpdb->query($sql);

}

function plugin_name_deactivate() {
	global $wpdb;
	$sql = 'DROP TABLE `' . $wpdb->prefix . 'plugin_name`';
	$wpdb->query($sql);

}

?>

A mi me han sido de utilidad en más de una ocasión, ya me contaréis.

Pero como bien dice Helen Bradley en este tutorial para photoshop en el que me he inspirado totalmente (ahora se dice así), hay pocas cosas que el Photoshop no pueda arreglar, o en este caso, el GIMP. Así que a continuación os explico como podéis arreglar una foto de ventanilla de avión con GIMP. Ésto sería un ejemplo:

Coger alguna de las fotos de avión de vuestros viajes y abrirla con el GIMP que empezamos.

Paso 1
Empezamos haciendo un duplicado de la capa de fondo para trabajar sobre él, y dejamos debajo el original por si luego lo necesitamos. Para ello, podemos pulsar en el botón de duplicar capa, hacerlo desde el menú Capa o pulsar Shift+Ctrl+D.

Paso 2
Seleccionamos la capa superior (sobre la que vamos a trabajar) y vamos al menú Colores->Niveles. El histograma de niveles te dice mucho sobre el estado de la imagen. En la mayoría de estos casos faltara blanco y negro, y la curva se verá concentrada en el centro. Así que para arreglarlo vamos a arrastrar los ‘sliders’ laterales -negro y blanco- hasta donde comienza la curva por cada uno de los lados. Al hacerlo se debería ver perfectamente un aumento en el contraste y un poco en el color también. Aceptamos y seguimos.

Paso 3
Arreglar problemas con el color. Con frecuencia, la imagen tendrá demasiado azul (u otro problema de tonalidad) y se puede arreglar mediante un ajuste de curvas, así que vamos al menú Colores->Curvas. Del desplegable de canales, vamos seleccionando el rojo, verde y azul, y probamos a mover la curva hacia arriba o hacia abajo dependiendo de si le queremos dar o quitar ese color. Se pueden hacer pruebas con la vista previa activada hasta que quede a tu gusto y aceptamos.

Paso 4
Al hacer la foto desde tan alto, suele tener mejor tonalidad en la zona de abajo, la más cercana al fotografo. Para compensar esto vamos a añadir una capa nueva y a hacer lo siguiente sobre ella. Con el negro seleccionado de color frontal y el blanco de fondo, elegimos la herramienta de degradado y hacemos uno de arriba a abajo (la zona superior debe ser negra y la de abajo blanca). Cuando lo tengamos listo, cambiaremos el ‘modo’ de la capa de ‘normal’ a ‘solapar’ (en un desplegable que hay sobre el listado de capas) y manejando la transparencia de esta capa lo dejamos al gusto.

Paso 5
Ahora le podemos dar los últimos retoques a la capa de la imágen tratada utilizando las herramientas del menú de Colores, saturación, contraste, brillo,… hasta que por fin se parezca más a lo que queremos.

Paso 6
Finalmente intentaremos darle un poco de nitided a la imagen, pero antes uniremos todas las capas en una pulsando en el menú Imagen->Aplanar Imagen. Ahora, para darle nitided vamos a intentar enfocar la imágen con un filtro de GIMP. Prueba a ir al menú Filtros->Realzar->Sharpen (si no lo tienes tendrás que instalar algún plugin para enfoque). Cuando lo tengas modifica el umbral del filtro hasta que te parezca que está bien y acepta. Hemos terminado.

Espero que os haya gustado, y ya sabéis, si lo probáis dejadme un enlace en los comentarios a vuestra imagen para ver el resultado.

El efecto no está hecho sobre fotos propias, así que podéis ver los originales de las fotos anteriores en los albumes de sus respectivos autores en flickr, reservasdecoches, dsearls. Para que podáis recrear el mismo efecto en vuestras fotos escribo este pequeño tutorial para GIMP.

Así que elegís la foto a la que queréis aplicarle el efecto y empezamos, las fotos buenas para este tipo de efectos suelen ser fotos aereas, sobre todo de edificios modernos que se encuentran en zonas antiguas. Una vez tengamos la foto abierta con el GIMP vamos a duplicar la capa actual, para ello vamos al menú Capa->Duplicar Capa, o más facilmente pulsamos Ctrl+Shift+D. Como luego vamos a borrar parte de esta capa, necesitamos añadirle el canal alfa -o transparencia-, así que seleccionamos la capa recién creada y vamos al menú Capa->Transparencia->Añadir canal alfa.

Ahora hay que agregar el efecto de desenfoque a esta capa superior. Para ello vamos al menú Filtros->Desenfoque (Blur)->Desenfoque Gaussiano. Depende de la foto deberemos desenfocar en mayor o menos medida, eso depende de vosotros.

Y para terminar,escogemos la herramienta borrador (Shift+E), y vamos borrando la capa desenfocada en las partes de la foto que queremos que parezcan una maqueta. Para borrar es mejor escoger un pincel difuminado, pero en algunos puntos puede que tengas que usar uno más solido.

Como veréis al ir borrrando la capa difuminada va quedando a la vista la capa original, mucho más marcada, dando la impresión en algunos casos de que la parte enfocada no es real y es una maqueta a escala. Espero que os haya gustado y como siempre que escribo un tutorial, me encantaría ver en los comentarios vuestras creaciones.

Lo primero que hay que hacer si se quieren desarrollar aplicaciones de Facebook, es tener una cuenta y agregarse la aplicación de desarrolladores. Cuando ya la tengamos agregada hay que pinchar en crear nueva aplicación, ponerle un nombre y enviar.

Lo que vamos a desarrollar es una aplicación web para Facebook, así que vamos a necesitar un sitio dónde alojarla, además vamos a escribirla en PHP y si queréis guardar datos necesitaremos una base de datos MySQL.

Cuando ya sepamos donde la vamos a alojar, nos vamos a nuestra aplicación en Facebook y vamos a editar sus datos. En la siguiente imagen se explican los parámetros de configuración que debemos rellenar en un inicio:

Ya tenemos todo configurado en la parte de Facebook, ahora solo nos queda crear nuestra aplicación y subirla a nuestro servidor. Como ya hemos dicho la escribiremos en PHP, pero primero debemos bajarnos la librería PHP de Facebook. La descomprimimos y la metemos en la carpeta dónde vayamos a alojar la aplicación.

Finalmente este es el hello world en PHP que debemos subir y guardar como index.php:

<?php

require_once 'facebook-platform/client/facebook.php';

$appapikey = 'XXXXXXXXXXXXXXXXXXXXXXX';
$appsecret = 'XXXXXXXXXXXXXXXXXXXXXXX';
$facebook = new Facebook($appapikey, $appsecret);
$user_id = $facebook->require_login();

echo "<p>Hola, <fb:name uid=\"$user_id\" useyou=\"false\" /></p>";

// Sacar por pantalla los cumpleaños de 20 de nuestros amigos
echo "<p>Cumpleaños de mis amigos:";
$friends = $facebook->api_client->friends_get();
$friends = array_slice($friends, 0, 25);
foreach ($friends as $friend) {
	$birthdate = $facebook->api_client->users_getinfo($friend, 'birthday');
	echo "<br>Id de usuario: " . $friend . " - Fecha de nacimiento: " . $birthdate[0]['birthday'] . "\n";
}
echo "</p>";
?>

Como veis en este script, primero incluimos la librería PHP de Facebook:

require_once ‘facebook-platform/client/facebook.php’;

Luego hay que escribir las API keys de nuestra aplicación que encontraremos en el panel de nuestra aplicación en Facebook.

$appapikey = ‘XXXXXXXXXXXXXXXXXXXXXXX’;
$appsecret = ‘XXXXXXXXXXXXXXXXXXXXXXX’;

Después creamos el objeto Facebook, y obtenemos el ID de usuario de la persona que accede a nuestra aplicación:

$facebook = new Facebook($appapikey, $appsecret);
$user_id = $facebook->require_login();

Printeamos un saludo utilizando el user ID y FBML, que es un lenguage tipo HTML especial para Facebook:

echo “<p>Hola, <fb:name uid=\”$user_id\” useyou=\”false\” /></p>”;

Y finalmente sacamos los IDs de 25 de nuestros amigos y su fecha de nacimiento si es que la han puesto:

// Sacar por pantalla los cumpleaños de 20 de nuestros amigos
echo “<p>Cumpleaños de mis amigos:”;
$friends = $facebook->api_client->friends_get();
$friends = array_slice($friends, 0, 25);
foreach ($friends as $friend) {
$birthdate = $facebook->api_client->users_getinfo($friend, ‘birthday’);
echo “<br>Id de usuario: ” . $friend . ” – Fecha de nacimiento: ” . $birthdate[0]['birthday'] . “\n”;
}
echo “</p>”;

Ésto ha sido todo, y como se puede ver al menos hacer un ejemplo no es muy dificil. A partir de aquí lo que os de la imaginación, estáis en vuestro servidor y podéis hacer casi lo que queráis. Para ver vuestra creación debeís acceder a http://apps.facebook.com/miaplicacion/, es decir, la página que habéis elegido como Canvas URL en la configuración.

Experimentad y ya me contaréis.

Editado: Ya he corregido el problema del que hablaban en los comentarios.