Archivo

Entradas Etiquetadas ‘plantillas’

Sed… de venganza (1): Sustituyendo cadenas en múltiples archivos

Lunes, 28 de Junio de 2010 Gaspar Fernández 1 comentario

3846929292_60721fb24e

Es uno de los grandes desconocidos y tan temidos comandos de que disponemos. Y es cierto que a veces da pereza mirarse el manual cuando queremos hacer algo que sed podría hacer rápidamente.

Lo que cuento hoy es su uso más popular (porque sed se puede usar para muuuuuchas cosas) y es muy simple, sustituir en un stream un texto por otro (Donde dije digo, digo Diego).

Imaginemos un fichero de texto, para ser originales llamémosle README, y en el texto queremos cambiar la palabra “Ireland” por “Spain”. Podemos hacer lo siguiente:

$ sed ’s/Ireland/Spain/g’ README

y veremos en pantalla el texto. Para guardarlo en el mismo archivo, si buscamos por Internet, veremos cómo la gente se complica la vida (que no digo que sea malo, yo también me la complico un poco más abajo), pero podemos usar el modificador -i (que tiene algunas funciones curiosas).

Si ahora hacemos:

$ sed -i ’s/Ireland/Spain/g’ README

Los cambios se guardarán automáticamente en el fichero README. Pero si investigamos un poco más, y queremos rematar la faena podemos hacer:

$ sed -i~ ’s/Ireland/Spain/g’ README

En este caso, guardaremos el cambio en el fichero README y grabaremos en README~ una copia de seguridad del fichero antiguo. La extensión de la copia de seguridad podemos cambiarla haciendo por ejemplo:

$ sed -i.bak ’s/Ireland/Spain/g’ README

Para que la copia sea README.bak

Pero ahora viene algo interesante, con el parámetro -i podemos modificar todos los archivos que queramos, sed acepta en la entrada múltiples archivos, por lo que si en un directorio con muchos archivos queremos cambiar un texto (imaginad que habéis hecho un proyecto relativamente grande, y hay una función con un nombre un poco ridículo, curiosamente es la que más veces llamáis, y como vamos a enseñar el código fuente, no queremos que nadie lea eso), podremos hacer:

$ sed -i ’s/nombre_ridiculo/nombre_elegante/g’ *

Ahora bien, si el proyecto está en múltiples directorios, siempre podemos usar find para localizar los archivos de la siguiente forma:

find -name ‘*.c’ -exec sed -i ’s/nombre_ridiculo/nombre_elegante/g’ {} \;

Con toda esta línea, buscaremos todos los archivos con extensión .c dentro del directorio actual y subdirectorios y se los pasaremos a sed, con el modificador -exec de find, ejecutaremos el comando que especificamos, donde {} indica el nombre de archivo (que nos lo da find) y con \; indicamos el fin del comando y sus parametros.

Pero esto no termina aquí, sed soporta expresiones regulares, y si por ejemplo queremos coger todas las imágenes de un fichero html, cambiarlas de directorio y añadirles un class (inicialmente encontramos <img src=”foto.jpg” alt=”" /> , y queremos que salga <img class=”imagen” src=”/static/foto.jpg” alt=”" />) podemos hacer lo siguiente:

sed ’s/src=”\(.[a-zA-Z\.\_\/]*\)”/src=”\/static\/\1” class=”imagen”/g’ fichero.html

Lo que hay en negrita, corresponde a la expresión regular que determina el nombre del archivo (caracteres de la a a la z, de la A a la Z, puntos, guiones bajos, y barras (en la cadena de origen), en la cadena de destino escribimos \1 donde queremos que coloque el texto correspondiente a la expresión anterior, es decir donde queremos que coloque el nombre del archivo.

Ni que decir tiene que podemos hacer una mezcla de todo lo dicho en este post ( expresiones regulares, y sustitución en múltiples archivos dentro de múltiples subdirectorios y guardando backups ), y estaremos delante de una potente herramienta.

Lo malo de ejecutar sed, es que tenemos que escapar muchos caracteres,por lo menos ), (, ., \, / y seguro que encontramos alguno más; para ello, siempre que queramos introducir un carácter de esos, debemos poner una contra barra (\) delante.

Foto: albertopveiga (Flickr)

Función curiosa: preg_replace_callback (PHP)

Lunes, 15 de Marzo de 2010 Gaspar Fernández 2 comentarios

A veces tenemos la necesidad de reemplazar un texto dentro de una cadena larga. Por ejemplo, el uso principal que le doy a esta función es el procesamiento de plantillas para páginas web, en donde tengo la página en HTML puro por un lado, y en su interior hay ciertas palabras clave, por ejemplo —seccionA—, —fotoUsuario—, —menuSesion—, etc; y en la web definitiva, aparecerá otra cosa en lugar de ese texto, aparecerá el objeto al que hace referencia.
Aunque cada cadena de texto seccionA, fotoUsuario, requiere un procesamiento distinto y es posible que no tengamos por qué procesar siempre todas las equivalencias de todos los textos. Queremos en definitiva reemplazar —seccionA— por el resultado de una función que ejecutaremos cuando encontremos ese texto. Sería como:

1
2
3
4
$disparadores=array("---seccionA---", "---fotoUsuario---", "---menuSesion---");
$reemplazos=array(dibuja_seccionA(), get_fotoUsuario(), dibuja_menuSesion);

$web=str_replace($disparadores, $reemplazos, $web);

Aunque, como dijimos, en el ejemplo anterior, se tienen que ejecutar dibuja_seccionA(), get_fotoUsuario() y dibuja_menuSesion().

Pero podemos aprovecharnos de las expresiones regulares, para extraer texto que esté entre “—” y “—” y pasar lo que hay entre medias a otra función que decidirá qué hacer; eso hace preg_replace_callback().

1
2
3
4
5
6
7
8
9
10
function quehacer($texto)
{
  switch ($texto[1]) // [0] devuelve: ---texto---, [1] devuelve texto
  {
     case 'seccionA': return dibuja_seccionA();
     case 'fotoUsuario': return get_fotoUsuario();
     case 'menuSesion': return dibuja_menuSesion();
  }
}
$web=preg_replace_callback('/---([a-zA-Z0-9_]*)---/', 'quehacer', $web);

Hasta aquí bien, el primer parámetro es una expresión regular (es un tema muuuy extenso), el segundo es la función a la que llamamos cuando encontramos el texto, y el tercero es de dónde lo sacamos. Bueno, ahora surge un problema, imaginad que necesito pasarle parámetros a esa función callback. Lo podemos hacer así:

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
function guardar_datos($data=null)
{
  static $guardados; // Una variable estática, muy importante

  // Si se especifica $data, lo guardamos en $guardados, al ser estática, aunque salgamos de la función, el valor de la variable no se perderá.
  if ($data)
    $guardados=$data;
 
  return $guardados;
}

function quehacer($texto)
{
  $datos = guardar_datos();

  switch ($texto[1]) // [0] devuelve: ---texto---, [1] devuelve texto
  {
     case 'seccionA': return dibuja_seccionA();
     case 'fotoUsuario': return get_fotoUsuario($datos);
     case 'menuSesion': return dibuja_menuSesion($datos);
  }
}

guardar_datos(array($datos_usuario, $datos_sesion));
$web=preg_replace_callback('/---([a-zA-Z0-9_]*)---/', 'quehacer', $web);

Nota: las variables $datos_usuario, $datos_sesion y $web no están definidas, como esto es parte de un programa, hay que imaginar un poco cuál será la información que contendrán.

Andanzas en Facebook: Publicar en el muro personal fácilmente

Martes, 11 de Agosto de 2009 Gaspar Fernández 25 comentarios

Desde el 20/12/2009 este método de publicación no está permitido por Facebook, para ver el nuevo método, ver este artículo.

Una de las cosas más comunes cuando se hace una aplicación para Facebook es la publicación de contenidos en el muro de la persona que ha ejecutado la aplicación. Esto al final es como un resultado de la ejecución de dicha aplicación (de hecho el objetivo de muchas de ellas es la publicación de un mensaje en el perfil), y de paso nos sirve como promoción para que más gente nos conozca.

La API de Facebook nos proporciona las herramientas para poder utilizar esta característica, que por ejemplo podemos llamar desde FBJS de la siguiente manera:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<script>
var template_id = xxxxxxxxx; // Es el identificador de nuestra plantilla de publicación, más adelante se explica cómo se obtiene este ID. (Sustituir las xxxxxxxxx con ese número).
// En la ventana de publicación, el texto que saldrá para pedirle a los usuarios que publiquen el resultado.
var user_message_prompt = "Comenta algo... si quieres";
// El texto de muestra que saldrá a la hora de publicar.
var user_message = {value: ""};

// La información que introducimos en la plantilla, por ejemplo imágenes y textos fijos que acompañarán nuestro mensaje
var template_data={"cuantagente":"0.04", "images":[{"src":"archivo.jpg", "href":"enlace"}]}
var body_general="Mensaje que aparecerá en el perfil junto a las fotos";

var continuation = function() {
// Podemos dejarlo en blanco si lo deseamos
};

Facebook.showFeedDialog( template_id, template_data, body_general, '', continuation, user_message_prompt, user_message );
</script>

Con este código, ya se mostraría la pantalla de publicación, podemos introducirlo dentro de otros scripts para que se dispare en el momento que nosotros queramos.

En la imagen vienen explicados algunos elementos:
Elementos en la publicación

El elemento template_data, incluirá la información de las palabras clave que hemos incluído en nuestra plantilla, como por ejemplo cuantagente, más adelante se hablará de ello; y además, las imágenes que se incluyen así como un enlace en cada una, todo esto en notación JSON. Básicamente, para no leer mucho, es un formato para intercambio de datos, pero usado también para declarar objetos en Javascript y se utiliza de la siguiente manera:

1
var objeto={"clave1":"valor1", [{"clave2-1":"valor2-1"},{"clave2-2":"valor2-2"}], "clave3":"valor3"};

La función continuation, se llamará una vez se cierre el diálogo de publicación, ya sea tras publicar el contenido como al cerrar la ventana sin publicar. No es posible determinar si se ha publicado o no, al menos Facebook no nos va a dar esa información.

Como hemos visto, es necesaria una plantilla de publicación (feed template), y ésta tendrá un código identificador (template bundle id), para conseguirlo, tenemos que entrar en la zona de administración de nuestras aplicaciones de Facebook (www.facebook.com/developers/apps.php).
Crear plantilla de publicación
A continuación, seleccionamos la aplicación.
Antes de continuar, tenemos que tener en cuenta que, dado que son plantillas, se establecerán palabras clave, que a la hora de la publicación serán sustituidas por lo que realmente significan, y en Facebook estas palabras claves tienen la siguiente forma: {*palabraclave*}. Por ejemplo, la palabra clave {*actor*}, a la hora de publicar un mensaje en el muro, se traducirá por el nombre del usuario que ha realizado la acción, en este caso, el nombre del usuario que acaba de ejecutar nuestra aplicación.

Dicho esto, primero tenemos que crear plantillas de una línea (one line templates), éstas se utilizarán en los resúmenes de los perfiles y, como nos indican en la ayuda del sistema suelen empezar por la palabra {*actor*}, serán las pequeñas historias que se publican en una línea, podemos poner enlaces (a la aplicación por ejemplo), en incluso más palabras clave.

En la siguiente pantalla, configuraremos el mensaje que aparecerá en los muros (el grande, con fotos y todo; aunque por ahora no nos preocupemos de la foto):
Configurando la plantilla
En esta plantilla hemos creado la palabra clave {*cuantagente*}, y más abajo, donde pone plantilla de datos simple, tenemos que escribir la correspondencia en notación JSON.

Tras ello, podemos incluir un enlace de acción o action link, lo más común es utilizarlo como un enlace a nuestra aplicación, será el que aparezca aquí:
Action Link
Debemos configurar el texto del enlace (podemos utilizar también palabras clave) y el enlace en cuestión, y ya sólo publicarlo. Tras ello, aparecerá en el centro de la pantalla una ventana de diálogo con el ID de la plantilla, y ese dato es el que debemos copiar en el código de arriba.
También podemos acceder más adelante a ese número y ver las plantillas que tenemos registradas, si accedemos a Registered Templates Console.

Podemos ver cómo algunas aplicaciones tienen más de un Action Link, para poder hacerlo nosotros, tenemos que hacerlo por código, registrando la plantilla desde la API, para más información, podéis visitar la wiki de desarrolladores de Facebook.

Para la inclusión de imágenes en la publicación, siguiente el ejemplo, tenemos que manipular template_data, añadiendo el elemento “images”, con el siguiente valor:

1
2
3
4
5
6
7
var template_data={"dato1":"valor1", "<strong>images</strong>":[
{"src":"archivo.jpg", "href":"http://www.miweb.com"},   // Imagen 1
{"src":"archivo2.jpg", "href":"http://apps.facebook.com/mi_aplicacion/"},   // Imagen 2
{"src":"archivo3.jpg", "href":"http://www.totaki.com/poesiabinaria"},   // Imagen 3
......
]
}

Visita otras webs de la red