Poesía binaria

Coloreando código con GeSHi

Gaspar Fernández — Sat, 04 Feb 2012 08:36:48 +0000

Cuando queremos publicar código fuente por Internet (como en esta web), debemos hacer que los usuarios se sientan bien con el código y que sea agradable de leer. Además del indentado, es de agradecer la introducción de colores, que separen palabras clave, identifiquen cadenas, funciones de biblioteca, funciones propias, números y demás elementos que encontramos en un fragmento de código.

Por Internet, podemos encontrar una biblioteca muy útil para este propósito: GeSHi. Vamos a intentar hacer algo sencillo con ella.

Para instalarla simplemente tenemos que descargarla y descomprimirla en uno de los directorios de nuestra web (no tiene por qué ser el principal), a continuación vamos a hacer un pequeño programa que mostrará el código fuente de un fichero PHP. Suponemos que geshi.php está situado en el mismo directorio que este ejemplo:

1
2
3
4
5
6
7
8
9
10

// Basado en los ejemplos de la página oficial

require_once("geshi.php");

$codigo=file_get_contents('mi_programa.php');

$ges=new GeSHi($codigo, 'php');

echo $ges->parse_code();

?>

Con este pequeño ejemplo, se mostrará de forma coloreada el código seleccionado, aunque es conveniente el uso de cachés, es decir, es una buena idea almacenar el código coloreado, es decir, el contenido que devuelve $ges->parse_code() en un archivo aparte y cargar directamente este archivo en la siguiente petición de la página. Por ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

include_once 'geshi.php'; 

function color_source_file($source_file, $language)

{

  $source_cache='cache/'.basename($source_file).'_'.$language.'.cache';

  if (@filemtime($source_cache)<filemtime($source_file))

    {

      $geshi= new GeSHi(file_get_contents($source_file), $language);

      $highlighted_source=$geshi->parse_code();

      file_put_contents($source_cache, $highlighted_source);

      return $highlighted_source;

    }

  return file_get_contents($source_cache);

}

$source = 'mi_programa.php';

echo color_source_file($source, 'php');

?>

Este código es capaz de guardar en un fichero el html generado por GeSHi en un archivo de caché (se guardará en un directorio llamado cache, el nombre del fichero será el mismo que el espeficado y su formato será [nombre]_[lenguaje].cache . La decisión se toma en base a las fechas de modificación de los archivos. Si el archivo de caché no existe (por eso la @ para que no devuelva fallos PHP) o su fecha de modificación es anterior a la fecha de modificación del archivo fuente, se generará un nuevo archivo de caché y se devolverá el código coloreado. Si no, se devolverá el código coloreado leyendo directamente del archivo de caché.

Activar números de línea

Lo podemos hacer así:

1	$ges->enable_line_numbers(GESHI_FANCY_LINE_NUMBERS);

Si ponemos GESHI_FANCY_LINE_NUMBERS cada 5 líneas saldrá el número en negrita, si ponemos GESHI_NORMAL_LINE_NUMBERS no sucederá así.

Resaltar líneas

Para resaltar líneas, debemos crear un array con los números de línea que queremos resaltar:

1	$lineas=array(5,6,7,43,53,54)

Y luego escribir:

1	$ges->hightlight_lines_extra($lineas);

Personalizando los estilos

Para ello podemos utilizar CSS. Por defecto GeSHi personaliza el style=”" de cada etiqueta, aunque genera mucho código html que podemos ahorrar. Para ello, podemos utilizar lo siguiente:

1 2	$ges->enable_classes(); file_put_contents('codigo.css', $ges->get_stylesheet(false));

Así crearemos un archivo .css que contendrá todos los estilos que puede tener un código fuente en un determinado lenguaje (en el cual hemos inicializado la clase), luego podemos incluir ese CSS ya generado en nuestro html resultante, y cambiar los colores, tipos de letra, etc.

GeSHi tiene muchísimas más opciones, para saber más, basta con un vistazo a la documentación oficial (en inglés) para descubrir todas las posibilidades de esta clase.

Linux en “Conspiración en la Red”

Gaspar Fernández — Thu, 02 Feb 2012 15:08:57 +0000

En España, se la conoce como “Hackers 3: Conspiración en la red”, aunque no tiene mucho de tercera parte; o sólo “Conspiración en la red”, en Europa también se llama “Conspiracy.com” y en EEUU, su título original es “Antitrust“. Es una de esas películas que hace varios guiños linuxeros, aunque aparezca un Tim Robins disfrazado de Bill Gates.

En el fotograma que vemos al principio del post, podemos ver claramente un escritorio Gnome, con sus iconos característicos justo en el minuto 2:15; además de muchas pantallas de Gnome y mucho código HTML en los títulos de crédito podemos encontrar una terminal donde ejecutan “ps”:

En el minuto 51:42 y pocos segundos después, podemos ver en una imagen de una cámara (que sale en un tono azulado, excepto un sombrero rojo (Red Hat), y un minuto más tarde se ve cómo verifica los dispositivos de almacenamiento montados con mount:

En general, la película tiene muchos guiños al software libre, como dicen en FayerWayer, podemos ver entre otras cosas:

A Miguel de Icaza, fundador del proyecto Gnome, entregando un premio a uno de los protagonistas.
Scott McNealy, CEO de Sun en 2001, entregando otro premio.
y muchas cosas más.

Publicando en Facebook como página para mantener a nuestros fans

Gaspar Fernández — Mon, 30 Jan 2012 20:15:01 +0000

Si administras una página de Facebook, esto te interesa, ya que puedes gestionar las publicaciones de forma automática, por ejemplo, si tienes muchas cosas que publicar y quieres hacerlo de manera escalonada, para no hacerlo todo seguido y mantener alerta a tus seguidores.

Para poder poner en práctica todo esto, te recomiendo leer estos artículos anteriores:

Estudiando el tema

El problema de administrar páginas, es que tienes que estar identificado como estas, y además, hacerlo en modo offline. Por otra parte, las páginas tienen sus administradores y éstos son los usuarios que se pueden identificar en aplicaciones.
Facebook hace todo esto a través de palabras de acceso (access tokens), cuando un usuario se identifica en una aplicación se genera un token único para ese usuario y éste durará un tiempo, durante ese tiempo, la aplicación podrá realizar las acciones que el usuario le ha dado permiso para hacer.

En el caso de las páginas, debemos generar un access token que valga para la página en cuestión que queremos manejar. Ese access token debemos pasárselo a la llamada a la API para publicar.

Obteniendo los access tokens de las páginas que administro

Para ello hay que hacer la llamada a la API /me/accounts, con lo que obtendremos un listado completo de las páginas que administramos, ID de páginas (para poder realizar las publicaciones) y los access tokens necesarios para publicar en nombre de esas páginas.

Podemos modificar el programa que teníamos para identificarnos (index.php) de la siguiente manera (facebook_ext está para descarga en un post anterior):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

$api_key = 'xxxxxxxxxxx';

$api_sec = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';

require_once('facebook_ext.php');

// Definimos constantes

define(NEEDED_PERMISSIONS,  'publish_stream,offline_access,manage_pages');

// Definimos códigos de error

define(NOT_INSTALLED,      1);

define(NO_PERMISSIONS,     2);

$facebook = new FacebookExtended(array(  

                       'appId'  => $api_key,

                       'secret' => $api_sec,

                       'cookie' => true ,

                     ));

try

{

  $sesion = $facebook->getUser();

  if (!$sesion)

    throw new Exception('Aplicación no instalada', NOT_INSTALLED);

  echo "Estamos identificados en Facebook
";

  echo "Usuario: ".$sesion."
";

  $permissions = $facebook->askForPermissions(NEEDED_PERMISSIONS); 

  if (!$permissions)

    throw new Exception('No tengo permisos suficientes', NO_PERMISSIONS);

  print_r($facebook->api('/me/accounts'));

} 

catch (FacebookException $e)

{

  echo "Error de Facebook: ".$e->getCode().": ".$e->getMessage();

}

catch (Exception $e)

{

  switch ($e->getCode())

    {

    case NOT_INSTALLED: 

      $facebook->loginUser();

      break;

    case NO_PERMISSIONS:

      $facebook->loginUser(NEEDED_PERMISSIONS);

      break;

    case MALFORMED_ARRAY:

      echo $e->getMessage();

      break;

    default:

      echo "Ocurrió un error no identificado";

    }

}

?>

Con este código, pediremos permiso para administrar páginas, para uso offline y para publicar mensajes en nombre del usuario. Cuando estemos identificados, nos devolverá un array con los nombres de las páginas, los ID y los access tokens. El array dentrá la siguiente forma:

Array
(
[data] => Array
(
[0] => Array
(
[name] => Nombre de página 1
[access_token] => xxxxxxx
[category] => Website
[id] => 123456789
)

[1] => Array
(
[name] => Nombre de página 2
[access_token] => xxxxxxx2
[category] => Website
[id] => 987654321
)
………………..
[n] => Array
(
[name] => Nombre de página N
[access_token] => xxxxxxxn
[category] => Website
[id] => 918273645
)
)
)

Se mostrarán todas las páginas que administramos. Ahora tendremos que anotar el ID de la página con la que queremos publicar y el access token para copiarlos en el código del programa encargado de publicar.

Publicando como si fuéramos una página de Facebook

Para hacer la publicación tenemos que hacer una llamada a /ID_de_página/feed especificando el access token con el que queremos publicar:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

$api_key = 'xxxxxxxxxxx';

$api_sec = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';

require_once('facebook_ext.php');

$facebook = new FacebookExtended(array(  

                       'appId'  => $api_key,

                       'secret' => $api_sec,

                       'cookie' => true ,

                     ));

try

{

  // ID de la página que queremos editar. La podemos ver en la URL de Facebook de la página

  $destino=189639191053576;

  $access_token='XXXxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';

  $public='Probando mensajes automáticos con el modo offline';

  print_r( $facebook->api('/'.$destino.'/feed', 'post', array('access_token' => $access_token,

                                  'message' => $public)));  

} catch (Exception $e)

{

  echo "Ocurrió un error";

}

?>

Facil, ¿no? Si trabajamos un poco con todo esto podemos conseguir automatizar los mensajes que se van a publicar en Facebook desde las páginas que gestionamos.

Publicando mensajes en Facebook sin que el usuario esté ahora mismo en la web [ modo offline ]

Gaspar Fernández — Fri, 27 Jan 2012 08:55:58 +0000

Una de las grandes utilidades que nos da Facebook por si creamos una aplicación de escritorio, o una aplicación web que publique posts de nuestro blog automáticamente en nuestro muro, son los mensajes Offline, con este modo, no es necesario que un usuario esté identificado realmente en Facebook, aunque, debemos tener cuidado a la hora de trabajar con la aplicación, los usuarios nos han dado permiso para publicar en su nombre contenidos que nosotros generamos, por lo que debemos evitar que se pueda acceder a la publicación de contenidos directamente. Es decir, lo que voy a mostrar ahora es un mero ejemplo de cómo se haría, aunque muestro un programa que es lo más inseguro del mundo, ya que, cualquiera que entre en la dirección web especificada podrá escribir en Facebook con nuestro ID de usuario.

Creando la aplicación y practicando la publicación

Para esto, hay dos posts anteriores que te recomiendo leer si no lo has hecho ya:

Creando dos interfaces

Por un lado necesitamos la interfaz que conecta con Facebook, tal y como la hemos hecho ya en el post anterior, desde aquí se pedirá permiso para poder publicar mensajes, y para poder acceder de forma offline. Este será nuestro index.php en los ejemplos (aunque podemos cambiarlo por cualquier página que destinemos a la identificación en Facebook).

Por otro lado, necesitamos el script que realmente va a publicar texto en Facebook, este script no debe identificarse en el sistema, sólo debe enviar la publicación (será en el ejemplo publica.php)

El código fuente completo podrás verlo y descargarlo al final del post.

Pidiendo permiso

Para escribir en Facebook con el modo offline, debemos pedir el permiso, concretamente el permiso offline_access. Con este permiso la palabra clave que nos da acceso con el usuario elegido no caducará (las claves normales, sin offline access, tienen una caducidad limitada, aunque funcionarán durante un tiempo (¿minutos?) aunque el usuario haya dejado de estar activo).

Para manejar los permisos de Facebook de una mejor forma, he extendido la clase Facebook con algunos métodos que nos ayudarán a la hora de pedir permisos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

  /**

   *************************************************************

   * @file facebook_ext.php

   * @brief Extensión de la clase Facebook que permite manejar

   *        algunas opciones de forma más intuitiva.

   *

   * @author Gaspar Fernández 

   * @version

   * @date 14 ene 2012

   * Historial de cambios:

   *

   *

   *

   *************************************************************/

require ('facebook.php');

class FacebookExtended extends Facebook

{

  private $permissions=false;

  function __construct($config)

  {

    parent::__construct($config);

  }

  function askForPermission($ext_perm, $uid=false)

  {

    if (!$uid)

      $uid=$this->getUser();

    if (!$this->permissions)

      $this->permissions=$this->api('/'.$uid.'/permissions');

    if ( (isset($this->permissions['data'])) && (isset($this->permissions['data'][0])) )

      return $this->permissions['data'][0][$ext_perm];

  }

  function askForPermissions($ext_perms, $uid=false)

  {

    $permArray = explode(",", $ext_perms);

    $permissionsOk=true;

    $nElems=count($permArray);

    for ($i=0; $i< $nElems; $i++)

      {

    $ext_perm=trim($permArray[$i]);

    if ($ext_perm!='')

      {

        /* Internal debug */

        /* echo $i.'-'.$this->askForPermission($ext_perm, $uid)."
"; */

        $permissionsOk= ($this->askForPermission($ext_perm, $uid) && $permissionsOk);

      }

      }

    return $permissionsOk;

  }

  function loginUser($permissions)

  {

    if ($permissions)

      $loginUrl=$this->getLoginUrl(array('scope'=>$permissions));

    else

      $loginUrl=$this->getLoginUrl();

    header('Location: '.$loginUrl);

    exit;

  }

};

?>

Esta clase, se encargará de preguntar por los permisos que necesitamos de forma automática (en realidad fue como se explicó en el post anterior, aunque cuando tenemos que preguntar por varios permisos nuestro código puede crecer bastante).

Ahora, para pedir permiso haremos lo sigueinte:

1
2
3
4

$permissions = $facebook->askForPermissions('publish_stream,offline_access');

  if (!$permissions)

    throw new Exception('No tengo permisos suficientes', NO_PERMISSIONS);

La excepción podemos crearla como queramos, yo he seguido la técnica del post anterior, que podréis observar mejor con el código completo, lo que está claro es que el código no debe continuar pasado este punto, y debemos pedir los permisos necesarios. Además, a la hora de pedir los permisos, con la clase que hemos visto anteriormente, podemos hacer lo siguiente:

1	$facebook->loginUser('publish_stream,offline_access');

Con lo que también nos ahorramos unas líneas de código.

También, para publicar en nombre de los usuarios debemos obtener un Access Token, es una palabra de acceso única que identifica al usuario de Facebook en nuestra aplicación y nos permite interactuar, para ver esta palabra debemos hacer:

1	echo $facebook->getAccessToken();

Publicando contenido

Para publicar contenido, ahora hemos creado el archivo publica.php que sólo publicará contenido en el muro, con este archivo tenemos que tener especial cuidado, ya que en este caso, cualquiera podrá publicar contenido nada más accediendo al archivo (Código fuente de publica.php):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

$api_key = 'Rellenar con nuestra API key';

$api_sec = 'Rellenar con nuestra API secret';

require_once('facebook_ext.php');

$facebook = new FacebookExtended(array(  

                       'appId'  => $api_key,

                       'secret' => $api_sec,

                       'cookie' => true ,

                     ));

try

{

  $destino="gaspy";     // O el nombre de usuario que queramos usar

  $public='Probando mensajes automáticos con el modo offline';

  $access_token='palabra que vimos cuando nos autorizamos, muy laarga';

  print_r( $facebook->api('/'.$destino.'/feed', 'post', array('access_token' => $access_token, 'uid' => $destino, 'message' => $public)));  

} catch (Exception $e)

{

  echo "Ocurrió un error";

}

?>

Ahora, para publicar contenido, en la llamada a la API debemos especificar:

uid = UID con la que queremos publicar, es decir, el usuario en nombre de quién hablamos.
message = Mensaje que queremos publicar
access_token = Palabra de acceso

Es más, podemos publicar en el muro o la página de quien queramos con esta técnica, igual que hacíamos antes, pero en este caso, lo hacemos sin que tengamos que estar identificados como ese usuario.

Código fuente de index.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

$api_key = 'Rellenar con nuestra API key';

$api_sec = 'Rellenar con nuestra API secret';

require_once('facebook_ext.php');

// Definimos códigos de error

define(NOT_INSTALLED,      1);

define(NO_PERMISSIONS,     2);

define(MALFORMED_ARRAY,   90);

$facebook = new FacebookExtended(array(  

                       'appId'  => $api_key,

                       'secret' => $api_sec,

                       'cookie' => true ,

                     ));

try

{

  $sesion = $facebook->getUser();

  if (!$sesion)

    throw new Exception('Aplicación no instalada', NOT_INSTALLED);

  echo "Estamos identificados en Facebook
";

  echo "Usuario: ".$sesion."
";

  $permissions = $facebook->askForPermissions('publish_stream,offline_access'); 

  if (!$permissions)

    throw new Exception('No tengo permisos suficientes', NO_PERMISSIONS);

  echo "No tienes que hacer nada, cierra esta ventana.";

} 

catch (FacebookException $e)

{

  echo "Error de Facebook: ".$e->getCode().": ".$e->getMessage();

}

catch (Exception $e)

{

  switch ($e->getCode())

    {

    case NOT_INSTALLED: 

      $facebook->loginUser();

      break;

    case NO_PERMISSIONS:

      $facebook->loginUser('publish_stream,offline_access');

      break;

    case MALFORMED_ARRAY:

      echo $e->getMessage();

      break;

    default:

      echo "Ocurrió un error no identificado";

    }

}

?>

Para descargar el código fuente: modooffline.tar.bz2 (1.7Kb)
Hay que incluir la API de Facebook para que funcione y sustituir $api_key y $api_sec por nuestra API Key y API secret respectivamente.

Foto: Samuel M. Livingston (Flickr)

KDE en Héroes

Gaspar Fernández — Thu, 26 Jan 2012 18:02:27 +0000

Una nueva entrega de software libre en películas y televisión. Esta vez podemos ver un entorno KDE y el uso de Kopete por parte de Niki Sanders, el personaje que encarna Ali Larter en Heroes:

Podemos ver este fotograma en el minuto 7 segundo 10 del primer capítulo de la serie titulado “Génesis”. Podemos ver bajo el vídeo una ventana de Kopete, que veremos unos segundos más tarde con más claridad:

Descubierto en: http://linuxontv.blogspot.com/2011/10/kde-on-heroes.html

Guardando un informe en nuestros proyectos PHP

Gaspar Fernández — Tue, 24 Jan 2012 16:16:38 +0000

Muchas veces, los proyectos en PHP crecen y crecen, y pueden ocurrir múltiples errores, tanto a la hora de crearlos como cuando ya están entregados al cliente final y debemos ofrecer soporte.

Por eso es importante ser rápido localizando los errores, y, siempre que la página, o el programa no haga algo como debe, debería tomar nota de qué ha pasado, cómo ha sido y de los datos involucrados con el fin de poder solventar el problema. Tengo que decir que debemos ser inteligentes con estos criterios, ya que un usuario malintencionado puede hacernos perder todo el espacio que tengamos disponible en nuestro servidor provocando errores; por ejemplo un script que funcione en Ajax y no se le hayan entregado los parámetros necesarios, puede ser útil saberlo en tiempo de desarrollo, pero no cuando el proyecto esté funcionando en la web, puede que incluso un motor de búsqueda mal entrenado se dedique a entrar en ese script y tumbarnos el programa.

Para hacer un informe, lo más fácil es hacerlo en un fichero de texto (podemos crear un XML sin mucho esfuerzo más, aunque va a ser algo que sólo vamos a leer nosotros y como mucho los administradores de la página, en muchos casos a los administradores no les dejaremos verlo).

Para esto, yo dispongo de una clase con funciones para guardar un informe de errores:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

  // Activa la depuración

define('__debug', true);

// Activa la visualización de los errores (sólo para modo desarrollo)

define('__debug_v', true);

class my_logger

{

  private $base_path;

  function __construct()

  {

    /** Sólo actuaremos si __debug es verdadero  */

    if (__debug)

      {

    define('__debug_file', 'my_log.log');

    define("__gf_dateformat_log", "d/m/Y H:i");

    // Si ejecutamos el programa desde consola. El directorio actual es PWD

    if (isset($_SERVER['DOCUMENT_ROOT']))

      $base_path=$_SERVER['DOCUMENT_ROOT'];

    elseif (isset($_SERVER['PWD']))

      $base_path=$_SERVER['PWD'];

    else

      $base_path='';

      }    

  }

/**

 ******************************************************************

 * @brief Escribir mensaje de error en pantalla

 *

 * To-do: Posibilidad de crear plantillas para este error desde el archivo de configuración

 *

 * @param $emsj    Mensaje de error

 * 

 * @return Nada

 *

 ******************************************************************/

  private function displayerror($emsj)

  {

    return '
.wordwrap('DEP: '.$h->T($msj),70,"\n").'
';

  }

/**

 ******************************************************************

 * @brief Extrae el nombre de una función o un método de un array 

 * de backtrace

 *

 * @param $bt_data  Array de backtrace

 * @param $index    Índice del array

 *

 * @return Array[3]={linea, Función o método (clase::metodo), fichero}

 *

 ******************************************************************/

  private function backtrace_function (&$bt_data, $index)

  {

    $bt_single=(isset($bt_data[$index]))?$bt_data[$index]:false;

    if (!$bt_single)        /* No data, no function */

      return false;

    $function=(isset($bt_single['function']))?$bt_single['function']:false;

    $class=(isset($bt_single['class']))?$bt_single['class']:false;

    $funcname=($class)?($class.'::'.$function):$function;

    $file=str_replace('path', '', $bt_single['file']);

    return array($bt_single['line'], $funcname, $file, $file.' ('.$funcname.', '.$bt_single['line'].')');

  }

  /**

 ******************************************************************

 * @brief Genera un fragmento de un error complejo. A menudo, esto

 *        incluye información del backtrace u otras cosas.

 *        Este método debe ser llamado desde preg_replace_callback()

 *

 * @param $data Datos enviados por preg_replace_callback()

 *

 * @return En qué se tiene que convertir la cadena enviada.

 *

 ******************************************************************/

  private function complexError($data)

  {

    if (!isset($data[1]))

      return $this->writelog('%%where%%: No se ha llamado desde preg_replace_callback(); Origen: "%%origen%%"');

    $btrace=debug_backtrace();

    switch ($data[1])

      {

      case 'where': 

    $wdata=$this->backtrace_function ($btrace, 4); /* Nivel 0: complexError; Nivel 1:preg_replace_callback(); Nivel 2: writelog;  Nivel 3: wlog(); Nivel 4: El que queremos */

    return $wdata[3];

    break;

      case 'origen':

    $wdata=$this->backtrace_function ($btrace, 5); /* Nivel 3: dónde llamamos a la función */

    return $wdata[3];

    break;

      case '-origen':

    $wdata=$this->backtrace_function ($btrace, 6); /* Nivel 3: dónde llamamos a la función */

    return $wdata[3];

    break;

      case '--origen':

    $wdata=$this->backtrace_function ($btrace, 7); /* Nivel 3: dónde llamamos a la función */

    return $wdata[3];

    break;

      default:

    return $this->writelog('%%where%%: No se encuentra la palabra clave: "'.$data[1].'"');

    break;

      }

  }

/**

 ******************************************************************

 * @brief Escribimos un mensaje en el log.

 *

 * @param $error     Error a escribir

 * @param $display   Mostrar error en pantalla (sólo si __debug_v vale true)

 *

 * @return false para usarlo como return de alguna función

 *

 ******************************************************************/

  function writelog($error, $display=false)

  {

    if ((__debug) && ($error))

      {

    $errorw=preg_replace_callback('/%%(.*?)%%/', array($this, 'complexError'), $error);

    $log_f = fopen(__debug_file, "a+");

    fputs($log_f, date(__gf_dateformat_log)." - ".$errorw."\n");

    fclose($log_f);

    if ((__debug_v)&&($display))

      $this->displayerror($errorw);

      }

    return false;

  }

};

$log = new my_logger();

function wlog($error, $display=false)

{

  $GLOBALS['log']->writelog($error, $display);

}

function genera_error()

{

  wlog("Genero un error nada más empezar y digo dónde está %%where%% llamado por %%origen%%");

}

function original()

{

  genera_error();

}

original();

?>

Cada vez que encontramos un error, podemos llamar a wlog() para guardar el informe del error que se guardará en un archivo de texto.

Mientras estamos desarrollando la aplicación podemos definir __debug_v a true para visualizar algunos errores (que previamente enviaremos con wlog(”error”, true)).

Además, a la hora de enviar un error, disponemos de las palabras clave %%where%%, %%origen%%, %%-origen%% y %%–origen%% para identificar automáticamente en qué función se ha producido el error, desde qué línea se llama así como la función desde donde se llama a la que provoca el error, y la anterior…

Si utilizamos la opción para averiguar automáticamente dónde está el error (la alternativa sería escribir el nombre de la función en el texto del error) tardará un tiempo en ejecutarse, ya que estamos escrudiñando dónde se ha producido, estamos haciendo un backtrace. De hecho la función PHP que genera ese informe es debug_backtrace() y nos resultará de gran ayuda para la depuración de nuestras aplicaciones.

Escribiendo en muros desde nuestra aplicación de Facebook

Gaspar Fernández — Sun, 22 Jan 2012 08:43:03 +0000

Uno de los usos más extendidos de las aplicaciones de Facebook es el de escribir en el propio muro o en el muro de nuestros amigos. Vamos a hacer un ejemplo de esto utilizando la Graph API de Facebook, a través de la biblioteca oficial que ellos nos dejan en GitHub. Para empezar a crear la aplicación os recomiendo leer este post anterior donde se dice paso a paso cómo se debe crear y cómo empezar a escribir código.

Pedir permiso para publicar

Antes de nada, debemos pedir permiso para publicar en el muro del usuario, para pedir permiso, lo podemos hacer en el mismo momento que ejecutamos el método getLoginUrl() pasando como parámetro un array cuyo único elemento será ’scope’ y su valor serán los permisos requeridos separados por comas. Por ejemplo:

1	$facebook->getLoginUrl(array('scope' => 'publish_stream'));

El permiso que debemos pedir para poder publicar en los muros de Facebook es stream_publish. Por otra parte, puede que ya hayamos identificado la aplicación con anterioridad, por lo que al estar dentro del sistema no hacemos llamada a getLoginUrl(), para ello debemos comprobar los permisos de que disponemos y eso lo hacemos con una llamada a la API a /usuario/permissions:

1	print_r($facebook->api('/me/permissions'));

Lo que nos devolverá un array con los permisos que dispone la aplicación, el array tendrá un elemento ['data'] que será otro array, cuyo elemento [0] contendrá otro array con los permisos:

Array ( [data] => Array ( [0] => Array ( [installed] => 1, [publish_stream] =>1 ) ) )

Publicar un mensaje en mi muro

Para publicar un mensaje en mi muro, debemos hacer una llamada a /usuario/feed y enviar por post la información referente al mensaje deseado:

1	$facebook->api('/me/feed', 'post', array('message' => $mensaje));

Código fuente demo

En este código fuente, he integrado excepciones para controlar los posibles errores (No identificado, No tengo permisos, Facebook me ha devuelto un array incorrecto), en este caso, los errores de identificación son salvables, pero los demás no. Para probar este código, debes cambiar la $api_key y la $api_sec:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

$api_key = 'xxxxxxxxxxxxx';

$api_sec = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';

require_once('facebook.php');

// Definimos códigos de error

define(NOT_INSTALLED,      1);

define(NO_PUBLISH_STREAM,  2);

define(MALFORMED_ARRAY,   90);

$facebook = new Facebook(array(  

                   'appId'  => $api_key,

                   'secret' => $api_sec,

                   'cookie' => true ,

                 ));

try

{

  $sesion = $facebook->getUser();

  if (!$sesion)

    throw new Exception('Aplicación no instalada', NOT_INSTALLED);

  echo "Estamos identificados en Facebook
";

  echo "Usuario: ".$sesion."
";

  // Obtenemos los permisos del usuario

  $permissions = $facebook->api('/'.$sesion.'/permissions');

  if (!isset($permissions['data'][0]))

    throw new Exception('Facebook ha devuelto un array mal formado', MALFORMED_ARRAY);

  if (!isset($permissions['data'][0]['publish_stream']))

    throw new Exception('No tengo permiso publish_stream', NO_PUBLISH_STREAM);

  $mensaje='Probando la publicación de mensajes en Facebook...';

  print_r( $facebook->api('/189639191053576/feed', 'post', array('message' => $mensaje)));

} catch (Exception $e)

{

  switch ($e->getCode())

    {

    case NOT_INSTALLED: 

      $login_url = $facebook->getLoginUrl();

      header('Location: '.$login_url);

      die();

      break;

    case NO_PUBLISH_STREAM:

      $login_url = $facebook->getLoginUrl(array('scope'=>'publish_stream'));

      header('Location: '.$login_url);

      die();

      break;

    case MALFORMED_ARRAY:

      echo $e->getMessage();

      break;

    default:

      echo "Ocurrió un error no identificado";

    }

}

?>

Publicando en otros muros y páginas

Para publicar en el muro de otros usuarios, simplemente tenemos que sustituir la dirección de la llamada a la API donde publicamos de /me/feed a /usuario/feed donde usuario es el texto que aparece al acceder en la dirección de la página principal de Facebook de alguno de nuestros amigos (también puede ser su ID de usuario, pero ya es difícil de obtener).

Para publicar en páginas debemos sustituir el /usuario/feed por /id_de_pagina/feed donde el ID de la página es el número que aparece en la dirección de la página en cuestión, si por ejemplo, la URL de la página de Facebook de este blog es:https://www.facebook.com/pages/Poesía-Binaria/189639191053576 ; la id de la página es la que está en negrita.

Sólo teniendo el permiso publish_stream ya podemos publicar con el nombre de usuario que tenemos actualmente en cualquier lado dentro de Facebook.

Linux en Alias

Gaspar Fernández — Thu, 19 Jan 2012 16:05:45 +0000

En la serie Alias, en el episodio 11 de la segunda temporada “Un Escalón Más Alto”, o “A Higher Echelon”, podemos ver este fotograma (casi en el minuto 17), en el que vemos un escritorio KDE y una terminal abierta.

Por otra parte, a lo largo del capítulo, se pueden ver varias pantallas como esta, en las que de fondo, si entornamos un poco los ojos, se está compilando con cc y con un argumento: “-D_GNU_SOURCE

Fuente: http://groups.google.com/group/comp.windows.x.kde/msg/3100d0f3062fac2a

Creando una aplicación para Facebook (paso a paso)

Gaspar Fernández — Wed, 18 Jan 2012 08:29:11 +0000

He decidido hacer esta guía porque Facebook anda cambiando los métodos para hacer aplicaciones y varias partes de su API. Los chicos de Facebook no paran de meter y sacar cosas y no dejan la página quieta. Después de hacer varias guías para “publicar definitivamente” en Facebook, van y cambian la forma de hacerlo.

Aunque parece que se han estabilizado, todos estos cambios han sido para llegar a la Graph API, se ha quedado bien hecha y estable, y yo creo que es posible aprender mucho de ella.

Aunque en esta guía empezaré desde el principio, desde que se crea la aplicación, paso a paso, ya que actualmente crear una aplicación vale para muchas cosas, no sólo para algo que resida dentro de Facebook sino para webs o clientes que funcionan fuera de Facebook e interactúan con la red social.

He de decir también que esta guía está hecha en Enero de 2012, por lo que si entras aquí en el futuro, puede que hayan hecho otro cambios definitivo más en Facebook.

Primer paso: Crear la App

Para ello debemos dirigirnos a https://developers.facebook.com/apps. Éste será nuestro centro de control de aplicaciones, donde podremos ver y editar los datos de éstas. Allí encontraremos en la parte superior de la página:

Pulsamos sobre Create New App, tras ello veremos un diálogo como este:

En el que en:

App Display Name debemos decir el nombre de nuestra aplicación, o si es una aplicación para identificarnos en una página, el nombre de la página. Es un nombre que la identifique.
App Namespace es el nombre que tiene nuestra aplicación en la URL de aplicaciones de Facebook. Es decir https://apps.facebook.com/AppNamespace . Dependiendo del ámbito de nuestra aplicación (si es accesible a través de Facebook.com o no) rellenaremos este campo o no.

Si continuamos, a veces la web de Facebook dará un error (comprobado el 7 de Enero de 2012), por lo que podemos volver a la página de las aplicaciones y continuar.

En la configuración de la aplicación, le damos a Edit Settings, y saldrá una pantalla así:

Aquí podremos rellenar el Namespace (mencionado antes), el mail de contacto y el dominio donde está alojada la aplicación (muy importante, ya que si la aplicación no está en el dominio indicado, no funcionará; además de la categoría de nuestra aplicación.

Por otra parte, arriba vemos la App ID y la App Secret. La primera es el identificador de nuestra aplicación, y la segunda una clave secreta que no se debe compartir con nadie para que la aplicación pueda interactuar con Facebook, algo así como el nombre de usuario y contraseña de nuestra aplicación. (Yo lo he puesto aquí, pero en realidad lo he regenerado varias veces).

La aplicación que crearemos servirá para enlazar una página web con Facebook y poder utilizar esa información, para eso debemos rellenar el apartado App Domain (por ejemplo minutodecaos.com), con el dominio donde estén alojadas las páginas de la aplicación, si no, la aplicación no estará autorizada y, un poco más abajo Site URL con la dirección exacta donde estará alojada nuestra aplicación.

Código fuente de la App

Es hora de crear nuestra aplicación en PHP. Lo primero que tenemos que hacer es descargarnos los archivos de la API desde esta dirección, dentro de GitHub. En principio trabajaremos en la web en modo local, por lo que creamos un directorio en nuestro disco duro (proyectos/facebook/tests/ dentro de mi home) Y descomprimimos los archivos dentro del directorio de nuestro proyecto. Aunque no es estrictamente necesario, yo lo he descomprimido dentro de lib/facebook, por lo que esos archivos estarán en $HOME/proyectos/facebook/tests/lib/facebook; y creamos el siguiente index.php (que luego subiremos al servidor junto con los ficheros de biblioteca de Facebook) :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

$api_key = 'xxxxxxxxxx';

$api_sec = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';

require_once('lib/facebook/facebook.php');

$facebook = new Facebook(array(  

                   'appId'  => $api_key,

                   'secret' => $api_sec,

                   'cookie' => true ,

                 ));

$sesion = $facebook->getUser();

if ($sesion)

  {

    echo "Estamos identificados en Facebook
";

  }

 else

  {

    echo "No estamos identificados en Facebook ";

    $login_url = $facebook->getLoginUrl();

    echo '.$login_url.'">Click para identificarte';

  }

?>

Este código nos mostrará, la primera vez que entremos: “No estamos identificados en Facebook. Click aquí para identificarte”, eso no significa que no hayamos entrado a la página de Facebook, significa que la página web no te ha identificado como usuario y de ser autorizada, por eso hacemos click en la pantalla anterior y aparecerá lo siguiente:

Login automático

Si no queremos mostrar el enlace para identificarnos en la aplicación, podemos utilizar el siguiente código:

1
2
3
4
5
6
7
8

if ($sesion)

   echo "Estamos identificados en Facebook";

else

{

   $login_url = $facebook->getLoginUrl();

   header('Location: '.$login_url);

   die();

}

Mostrando datos de usuario, o cogiéndolos

En la parte de “Estamos identificados en Facebook”, podemos hacer:

1
2
3
4
5
6
7

if ($sesion)

{

   echo "Estamos identificados en Facebook
";

   echo "Usuario: ".$sesion."
";

   $userData = $facebook->api('/me');

   echo nl2br(print_r($userData, true));

}

Con estas líneas podemos ver información del usuario que está actualmente identificado en nuestra aplicación, y podremos utilizar los datos del array $userData:

['name'] - Nombre completo del usuario
['first_name'] - Nombre
['last_name'] - Apellidos
['link'] - Enlace a la página del usuario en Facebook
['username'] - Nombre de usuario de Facebook
['about'] - Frase personal
['gender'] - Género
y mucho más que podemos ver cuando ejecutamos el ejemplo anterior

Ahora en Facebook, siempre que queramos acceder a información tanto de páginas, grupos, usuarios, etc, sólo tenemos que acceder a través de la llamada a api(’/localizacion’), con la palabra especial /me, como hemos visto para el usuario actual. Esto nos puede ayudar a identificarnos en nuestra web, sin pedir usuario, ni contraseña, a través de la Graph Api.

5 Aplicaciones que me salvan día a día

Gaspar Fernández — Sun, 15 Jan 2012 15:23:30 +0000

Son pequeñas aplicaciones sin las cuales no podría salir adelante día a día. Aunque a veces no las mime demasiado y no les haga mucho caso, deberían saber que son importantes para mí, para mi vida online y yo informático. He intentado establecer un orden, pero todas ellas son muy importantes, por lo que ocuparían todas la primera posición:

Keepnote

Es un software muy completo y ligero para tomar notas, clasificarlas y buscar dentro de ellas. De todos los que he probado es el que mejor sensación me ha dejado con respecto a su facilidad de uso, velocidad y características. Disponible en Linux, Mac y Windows
KeepassX

Es un gran programa para anotar nuestras contraseñas y anotaciones para cualquier tipo de identificación electrónica (webs, banca online, routers, etc). Puedes ordenar las contraseñas por categorías, asignarles iconos, buscarlas, etc. Es muy fácil de utilizar, y guarda la información cifrada para que nadie más que tú pueda verla. Disponible para Linux, Mac y Windows
Grisbi

Un software para organizar mi economía personal, saber cuánto dinero tengo en la cartera y en el banco, quién me debe y a quién le debo. Es muy completo y funciona en Linux, Mac y Windows.
Emacs

Llamadme friki, pero es mi editor de texto / IDE favorito para programar. Con multitud de opciones, automatizable, personalizable y todo a mano, aunque para aprender fue algo difícil en principio, una vez que sabes las cuatro cosas básicas, todo va sobre ruedas, y cada día me gusta más (excepto la opción deshacer, pero bueno, nadie es perfecto). Funciona en Linux, Mac, Windows, *BSD, Solaris y algunos más
Hotot

Un cliente para Twitter muy ligero, cómodo e intuitivo. Hay muchos clientes para microbloguear, pero con éste es con el que me siento más cómodo. Disponible para Linux, Mac, Windows y Chrome, aunque para Windows y Mac es bastante inestable aún.

En algunos de estos proyectos, y en otros más intento colaborar de diferentes formas, aunque a veces no en la medida que me gustaría, por falta de tiempo, como pasa siempre:

Clicks en la publicidad de sus webs oficiales
Perfeccionamiento de traducciones
Haciendo que más gente los utilice
Reportando bugs
Sugiriendo características

Y vosotros, ¿cómo colaboráis con vuestros proyectos preferidos? ¿Cuáles son esos 5 programas sin los que no podríais vivir?