dialelo

Automatiza la ejecución de tus tests en Python con tdaemon

2012-08-12T00:00:00-07:00

El desarrollo guiado por pruebas o Test-Driven Development (en adelante TDD) es un ciclo de desarrollo que consiste en aplicar el siguiente algoritmo:

Escribir un test automático que verifique una funcionalidad.
Ejecutar la prueba y verla fallar.
Escribir el mínimo código que haga a la prueba pasar.
Refactorizar para eliminar duplicidad y conseguir un código limpio.

Los beneficios de utilizar esta práctica son numerosos, desde mantenerte concentrado en una sola tarea cada vez hasta generar una documentación viva (en código) de la especificación del sistema que estamos desarrollando.

Para una muy buena introducción al TDD en español recomiendo el libro Diseño Ágil con TDD de Carlos Ble.

tdaemon

tdaemon vigila un directorio y ejecuta los tests automáticamente cada vez que detecta un cambio.

Esto nos permite un flujo de trabajo TDD sin necesidad de ejecutar las pruebas manualmente. tdaemon está disponible en PyPI para su descarga, por lo que podemos instalarlo con pip fácilmente.

tdaemon utiliza un programa adicional para ejecutar los tests, que por defecto es nose. nose descubre los tests de forma automática y es extensible mediante plugins.

Vamos a instalar ambos programas para probar su funcionamiento:

$ pip install nose tdaemon

Una buena forma para tener feedback de los tests a medida que cambiamos el código es utilizar dos paneles en una ventana de tmux, una para el editor y otra para ejecutar tdaemon. Si te interesa saber más sobre tmux mi artículo sobre productividad con VIM y tmux merece unos minutos de tu tiempo.

Para empezar a utilizar tdaemon no tenemos más que ejecutarlo en el directorio que queremos monitorizar. Opcionalmente podemos pasarle como argumento la ruta hasta el directorio que queremos que vigile. Aquí vemos como detecta un cambio y ejecuta los tests automáticamente:

$ tdaemon
Ready to watch file changes...
2012-08-12 18:06:46.964502
..................EE.....
======================================================================
ERROR: Failure: ImportError (cannot import name create_status)
----------------------------------------------------------------------
# ...

Integración con Django

tdaemon soporta otros programas para ejecutar los tests, entre los que están py.test y el test runner de Django.

Para utilizar tdaemon en un proyecto Django, no tenemos más que invocarlo de la siguiente forma (en el directorio donde vive nuestro manage.py):

$ tdaemon --test-program=django --custom-args="mi_app"
# que ejecutará: 
#   $ ./manage.py test mi_app
# cada vez que detecte un cambio

Esto es todo por hoy, espero que os sea útil. Y vosotros ¿cómo hacéis TDD en Python?

Recursos para aprender Python

2012-06-28T00:00:00-07:00

En este artículo pretendo recopilar enlaces relacionados con Python que puedan servir tanto a principiantes como desarrolladores expertos. La intención es hacer de este artículo un documento vivo e ir añadiendo enlaces a medida que los propongáis; también añadiré la información que encuentre por las interwebs.

Documentación

Quizá quieras empezar leyendo el tutorial de Python en español.

El sitio más obvio para aprender Python es la documentación oficial, es completísima y de mucha calidad. Definitivamente tienes que guardarla en tus marcadores.

A continuación enumero algunos recursos que me han ayudado muchísimo a la hora de aprender:

Python guide está en desarrollo pero es muy prometedora, recomiendo a los principiantes leerla para absorber buenas prácticas desde el momento en que comienzan a experimentar con el lenguaje.
Python Module Of The Week contiene artículos cubriendo gran parte de la librería estándar con ejemplos y artículos de muy buena calidad. Suelo consultarlo como referencia y cuando quiero probar algún módulo que desconozco.
Code like a Pythonista: Idiomatic Python es un documento que describe buenas prácticas a la hora de escribir código, existe una traducción al español por Raúl González Duque.
pep8 es la guía de estilo Python que todo programador debería leer. Existe una versión traducida al español también por Raúl.

Literatura

No he leído muchos libros sobre Python así que espero sugerencias para incluir en esta sección.

Dive into Python es un libro gratuito que enseña Python a base de ejemplos. Yo empecé a aprender leyéndolo y lo recomiendo si te gusta experimentar y learn by doing.
Los libros de Mark Lutz han sido recomendados por Joe Di Castro.
Python para todos es un libro completo y para todos los niveles en español.

Sitios web

El agregador de blogs oficial de Python contiene artículos escritos por miembros destacados de la comunidad, ahí puedes encontrar contenido de mucha calidad escrito por programadores expertos.

Blogs en español

Pybonacci es un blog dedicado a la uso de Python en la computación científica en español. Aunque no vayas a utilizar Python con dichos fines te recomiendo echarle un ojo.

Comunidades

El subreddit de Python es un sitios fantástico para encontrar buenos artículos sobre Python. Si estás dando tus primeros pasos quizá te sea útil el subreddit para aprender Python.
El sitio de preguntas y respuestas Python Majibu es un sitio genial para interactuar con la comunidad hispanohablante de Python. El hombre detrás del proyecto es Joe Di Castro, ¡kudos para él!
Python Argentina y Python Hispano son comunidades de entusiastas Python hispanohablantes.

Ejercicios

En Python Challenge y Project Euler puedes practicar lo aprendido después de leer alguno de los recursos de este artículo.

Programadores

Una buena forma de aprender a escribir buen código es aprendiendo de programadores expertos, e incluso colaborando en sus proyectos. A continuación presento una lista de algunos de los que más me han inspirado:

Armin Ronacher es el autor de Pygments, Sphinx y Flask entre otros muchos proyectos.
Kenneth Reitz es el autor de la popular librería requests, un programador muy prolífico y un tipo muy amigable.
Adrian Holovaty y Jacob Kaplan-Moss son los autores del popular framework para desarrollo web Django.

Boletines de noticias

Python Weekly y Pycoder’s Weekly son dos boletines de noticias semanales con artículos y proyectos Python.

¿Qué recursos recomiendas tú?

Los beneficios de liberar el código de turses

2012-06-20T00:00:00-07:00

En este artículo voy a hablar de los beneficios que me ha aportado liberar el código de mis proyectos, concretamente de turses, esperando que anime a más de uno a hacer lo mismo.

Comunidad

Lo que más me fascina del software libre son las comunidades de personas que invierten su tiempo y esfuerzo por un bien común.

Empecé a trabajar en turses porque quería usar Twitter desde la consola y no encontré ningún programa que se adaptara a mis necesidades. Cuando empecé a publicar las primeras versiones insistí a algunos de mis amigos para que se lo instalaran y me dieran feedback, y sus sugerencias me ayudaron a pulir detalles que no habría sido capaz de percibir por mi cuenta.

A medida que el proyecto ha ido avanzando algunas personas han empezado a utilizarlo por su propia voluntad, y:

Me han ayudado a descubrir y arreglar bugs;
han sugerido e implementado nuevas funcionalidades y mejoras;
y hemos hablado sobre la dirección que podría tomar el proyecto.

En definitiva, juntos hacemos que turses sea mejor en cada nueva versión, y estoy muy agradecido por su tiempo y paciencia. Al crear comunidad alrededor de un proyecto éste cobra mucho más sentido, y, sinceramente, que esa comunidad exista me motiva muchísimo a dedicarle tiempo.

Aprendizaje

A pesar de ser un programa muy pequeño (~5000 líneas de código) estoy aprendiendo muchísimo escribiéndolo. Algunas de las cosas que me está aportando son:

Un mayor conocimiento del lenguaje de programación Python y su librería estándar;
la habilidad de aplicar patrones de diseño para resolver problemas comunes en el desarrollo de software;
comprender la importancia de escribir pruebas para asegurar la corrección de un programa y evitar regresiones;
la necesidad de mejorar mi inglés para mantener una buena comunicación con las personas involucradas en el proyecto.

Productividad en la consola con VIM y tmux

2012-06-18T00:00:00-07:00

En este artículo voy a hablar sobre dos herramientas que utilizo en conjunto para desarrollar: VIM y tmux.

VIM

Un editor de texto es la herramienta más importante de un programador. Pasamos la mayor parte del tiempo dentro de él, así que es deseable que:

Podamos extenderlo con scripts o plugins para automatizar las tareas repetitivas e incorporar funcionalidad inexistente en el editor;
se integre a la perfección con programas de terceros;
no se interponga entre nuestras ideas y la codificación de éstas.

Me inclino por VIM, pero Emacs es también una buena opción. Ambos tienen una curva de aprendizaje un tanto empinada pero una documentación y comunidad excelentes. Creo que dominar uno de estos dos editores de texto te hará un mejor programador y, sobre todo, incrementará tu productividad.

tmux

tmux es un multiplexor de terminales. Permite tener múltiples ventanas compuestas de paneles con una terminal en cada uno.

De entre los beneficios de usar tmux destacaría los siguientes:

Permite visualizar varias terminales simultáneamente;
puedes redimensionar paneles a placer o usar alguno de los layouts disponibles y dejar que tmux lo haga por ti;
provee un portapapeles que permite copiar texto entre paneles;
es programable y extremadamente configurable.

Integrando ambas herramientas

Suelo utilizar una sesión de tmux por proyecto, donde tengo abierta una ventana con el editor y las terminales que hagan falta: servidor, documentación, ejecución de pruebas, etc.

Para organizar mis sesiones de tmux utilizo una gema llamada tmuxinator.

tmuxinator

tmuxinator nos permite declarar sesiones de tmux en YAML, que es fácil de leer para una persona, en vez de escribir un script para crear la sesión.

Para declarar una sesión ejecutamos el comando

$ mux open <nombre>

que abrirá nuestro $EDITOR para editar una sesión con el nombre que indiquemos.

Ésta es la sesión que utilizo para desarrollar turses:

project_name: turses
project_root: ~/repos/turses/
pre: uzbl-tabbed http://github.com/alejandrogomez/turses/issues &
tabs:
  - dev: vim .
  - ipy: ipython
  - docs: cd docs && vim .

La sesión se compone de tres ventanas: una para desarrollar, otra para el intérprete de Python y la tercera para escribir documentación. El comando en pre abre un navegador con el issue tracker del proyecto.

Cuando ejecuto

$ mux turses

se abre una nueva sesión de tmux (si no estaba abierta ya) conteniendo las ventanas declaradas en el fichero YAML.

vimux

vimux es un plugin de VIM que permite interactuar con tmux desde el editor. Podemos lanzar un comando mientras estemos editando y se abrirá un panel, dividiendo horizontalmente la ventana actual.

Por ejemplo podemos llamar a nosetests para ejecutar nuestra suite de pruebas en un proyecto Python con el siguiente comando:

:call RunVimTmuxCommand("nosetests")

vimux también provee un atajo para repetir el último comando ejecutado:

:RunLastVimTmuxCommand

turses. Un cliente de Twitter con interfaz curses

2012-03-02T00:00:00-08:00

He estado más de un mes sin escribir en el blog pero la verdad es que no he parado. Entre Mutualismo, del que esperamos sacar una beta en menos de dos semanas; mi PFC, al que tengo que dedicar la mayor parte del tiempo del que dispongo y turses, un cliente de Twitter con interfaz ncurses que estoy escribiendo en Python.

Hace algún tiempo descubrí Tyrs y me encantó, tenía exactamente lo que buscaba en un cliente de Twitter:

una interfaz curses agradable a la vista;
personalización completa (mociones, acciones y programas externos);
escrita en un lenguaje de programación que me es familiar.

Después de usarlo un par de semanas empecé a echar de menos cosas como:

mover buffers a placer;
añadir y borrar buffers dinámicamente para:
- hacer búsquedas;
- visualizar una conversación;
- ver el perfil de un usuario;
- ver los tweets de una lista.

Decidí contribuir al proyecto implementando alguna de estas funcionalidades. Me familiaricé con el código y, a pesar de ser un programa totalmente funcional, encontré que hay un gran acoplamiento y todos los componentes conocen muchos detalles de los demás.Esto hace que sea más complicado añadir y/o modificar partes del programa.

Así que empecé una implementación desde cero, reusando gran parte del código del proyecto. Aún está en fase beta, aunque ya tiene implementadas algunas funcionalidades básicas. He aquí un par de screenshots:

Si os interesa podéis ver el código. Me vendría muy bien un poco de ayuda, aunque sea probándola y reportando bugs.

Entornos virtuales de Python con pip, virtualenv y virtualenvwrapper

2012-01-08T00:00:00-08:00

Como prometí en un artículo anterior voy a hablaros de tres herramientas que todo desarrollador Python debería conocer: pip, virtualenv y virtualenvwrapper.

Cuando estamos trabajando en varios proyectos que utilizan Python instalar sus dependencias a nivel de sistema es una mala idea ya que:

puede causar conflictos si dos proyectos utilizan distintas versiones del mismo paquete;
resulta más complicado mantener una lista de dependencias;
ensuciamos la instalación global de Python con paquetes que no utilizamos en el día a día.

Es por ello que aislar las dependencias en un entorno virtual de Python hace mucho más cómodo y eficiente trabajar en un proyecto.

Vamos a ver qué es y cómo utilizar cada herramienta de las mencionadas.

pip

pip es la forma mas sana de instalar paquetes de Python que conozco, además de ser útil para hacer un seguimiento de las dependencias de un proyecto. Es muy sencillo instalar paquetes de Python con pip:

$ pip install fabric

Si queremos conocer los paquetes Python que tenemos instalados utilizamos la opción freeze:

$ pip freeze
Fabric==1.3.3
Pygments==1.4
pycrypto==2.4.1
ssh==1.7.11
wsgiref==0.1.2

Para desinstalar un paquete hacemos:

$ pip uninstall fabric

virtualenv

virtualenv es una herramienta que permite crear entornos virtuales de Python independientes de la instalación global. Para instalarlo y crear un entorno virtual hacemos:

$ pip install virtualenv
$ virtualenv env
New python executable in env/bin/python2
Also creating executable in env/bin/python
Installing setuptools............done.
Installing pip...............done.
$ cd env/
$ ls -F
bin/            
include/
lib/

Veamos qué contiene el entorno virtual que acabamos de crear para comprender mejor su funcionamiento:

bin contiene los binarios de Python, pip y easy_install además de varios scripts para activar el entorno virtual.
include contiene un enlace simbólico al directorio donde están contenidos los headers de la versión de Python que estemos utilizando, en mi caso apunta a /usr/include/python2.7.
lib contiene los paquetes que hemos instalado en el entorno virtual.

Hemos creado un entorno virtual, veamos cómo activarlo e instalar paquetes en él:

# activamos el entorno
$ source bin/activate            
$ pip freeze                     
wsgiref==0.1.2
# instalamos un paquete
$ pip install ipython            
# ...
Successfully installed ipython
Cleaning up...
$ pip freeze
ipython==0.12
wsgiref==0.1.2

El script bin/activate modifica la variable de entorno PATH para tener disponibles los paquetes del entorno virtual y cambia nuestro PS1 añadiendo al principio el nombre del entorno que hemos activado.

Ahora tendremos disponibles los paquetes instalados en el entorno virtual independientemente de la instalación global. Cuando terminemos de trabajar en dicho entorno, lo desactivamos.

$ deactivate

virtualenvwrapper

virtualenvwrapper es un conjunto de extensiones a virtualenv que, entre otras funcionalidades, provee:

centralización de los entornos virtuales en un único directorio;
wrappers para la creación, copia y borrado de entornos virtuales;
un script para movernos entre entornos fácilmente;
autocompletado para comandos que reciben un entorno virtual como argumento.

Antes de nada tenemos que inicializar virtualenvwrapper como sigue:

# especificar un directorio donde se alojen los entornos
$ export WORKON_HOME=~/.virtualenvs
$ mkdir -p $WORKON_HOME
# activar virtualenvwrapper
$ source /usr/local/bin/virtualenvwrapper.sh

Nos interesará ejecutar el script virtualenvwrapper.sh cada vez que abrimos una terminal así que añade la última línea al fichero de inicialización de tu consola. La ruta del script puede variar en tu distribución así que comprueba primero dónde se encuentra.

Crear, copiar y eliminar entornos virtuales

Los comandos para crear, copiar y eliminar entornos virtuales son los siguientes:

# crear entornos virtual
$ mkvirtualenv scripting
$ mkvirtualenv web
# crear un entorno copiando otro
$ cpvirtualenv scripting jugar
# borrar un entorno 
$ rmvirtualenv scripting

Moverse entre entornos virtuales

El comando workon nos permite movernos entre entornos virtuales muy fácilmente. Además tenemos disponible el autocompletado para los nombres de los entornos.

# activar el entorno 'web' 
$ workon web
# moverse al entorno 'scripting'
$ workon scripting

Un último consejo

Podemos mantener un fichero con las dependencias de un proyecto fácilmente gracias a pip y virtualenv, haciendo:

$ pip freeze > pip-requirements.txt

Cuando queramos instalar dichas dependencias en un nuevo entorno no tenemos más que crearlo y ejecutar el siguiente comando con el entorno activado:

$ pip install -r pip-requirements.txt

Esto es muy útil al trabajar desde diferentes máquinas o al desarrollar un proyecto de forma colaborativa ya que nos permite tener las mismas versiones de las dependencias en cualquier lugar.

Me gustaría leer opiniones y recoger un poco de feedback sobre la forma que teneis de gestionar los distintos proyectos en los que desarrolláis con Python.

Happy hacking!

Taming dependencies with pip - Carl Meyer

2011-12-26T00:00:00-08:00

Si programais en Python seguramente habreis utilizado pip o easy_install para gestionar paquetes. pip se postula como el sustituto de easy_install en cuanto a la instalación de paquetes y gestión de dependencias entre los mismos.

Usado junto a virtualenv nos permite aislar conjuntos de módulos Python para usarlos en proyectos específicos. En una entrada futura hablaré de cómo gestionar entornos virtuales con dicha herramienta.

En esta charla Carl Meyer explica la forma en que pip encuentra e instala paquetes, gestiona las dependencias y da consejos sobre su configuración.

Javascript programming style and your brain - Douglas Crockford

2011-12-18T00:00:00-08:00

Voy a recomendar vídeos de conferencias o workshops que considero interesantes semanalmente. Para empezar he elegido una conferencia de Douglas Crockford, experto en JavaScript reconocido por popularizar el formato JSON y programar JSLint.

Douglas Crockford - JavaScript Programming Style and Your Brain de pixilated ideas en Vimeo.

Además de ser una charla entretenida enseña buenas prácticas a la hora de escribir JavaScript, habla de las virtudes y defectos del lenguaje y señala algunos errores que son fáciles de cometer y difíciles de descubrir.

Muchos consejos son aplicables a otros lenguajes también, así que si decides verlo seguro serán 45 minutos de tu vida muy bien invertidos.

Scripting con BeautifulSoup

2011-12-10T00:00:00-08:00

En este artículo explicaré mediante un sencillo ejemplo cómo utilizar las librerías urllib2 y BeautifulSoup para escribir scripts que recorran sitios web extrayendo información. También podemos utilizarlas para automatizar tareas repetitivas que hagamos en ciertas páginas web.

urllib2 nos permite abrir sitios web como ficheros y BeautifulSoup es un parser de documentos XML. Al combinar las dos librerías tenemos muchas posibilidades. Como soy aficionado al manga he escrito un script que se descargue de submanga el último capítulo de mis mangas favoritos.

Lo primero que haremos será una función que obtenga el contenido de una URL y genere un objeto BeautifulSoup que nos permita recorrer el HTML de forma sencilla.

from urllib2 import urlopen

from BeautifulSoup import BeautifulSoup


BASE_URL = 'http://submanga.com'

def soup(url):
    response = urlopen(url)
    return BeautifulSoup(response.read())

Las URL de la página principal de cada serie son de la forma http://submanga.com/Nombre_serie y en ellas tenemos varios enlaces a los últimos episodios de la serie. Vamos a escribir una función para averiguar el número y URL del último episodio de una serie dada.

Si observamos el árbol DOM de la página principal de una serie, vemos que:

La lista de los últimos capítulos es un tabla;
las celdas de dicha tabla tienen el atributo class="u";
cada celda tiene un enlace a la URL del episodio;
el texto del enlace contiene el número del episodio.

Vamos a escribir la función que devuelve el número y URL del último episodio de una serie.

def last_episode(serie):
    """
    Returns a tuple with the last episode's number and URL for the given serie.
    """
    serie_url   = '/'.join([BASE_URL, serie])
    html        = soup(serie_url)    
    us          = html.findAll(attrs={'class': 'u'})
    episode_num = us[0].a.strong.text
    episode_url = us[0].a['href']
    return int(episode_num), episode_url

Ahora tenemos la URL del último episodio, que nos lleva a la página principal de dicho episodio. Si abrimos esa página, observamos que contiene un enlace al visor de comics de submanga para dicho episodio. Como el enlace tiene un id concreto extraemos dicha URL muy fácilmente.

def episode_pages_url(episode_url):
    """
    Receives the URL of the main page of an episode and returns the URL where 
    the episode pages are located.
    """
    html = soup(episode_url)
    url  = html.findAll(attrs={'id': 'l'})
    return url[0]['href'] if url else u''

Ahora vamos a analizar el visor de comics para poder navegar por las páginas del episodio y descargar las imágenes.

Cada página contiene una imagen dentro de un enlace que lleva a la siguiente. Dicho enlace e imagen están contenidos dentro del primer div así que es fácil extraerlos.

Cuando terminamos de leer un episodio tenemos una página especial que nos permite o volver a leer el episodio o pasar al siguiente.

Estamos en condiciones de escribir funciones que nos permitan saber todas las URL correspondientes a las páginas de un episodio concreto. page_urls recibe como parámetro el enlace a la primera página del visor de comics, que hemos extraído previamente con episode_pages_url, y genera una lista con todas las URL de todas las páginas del manga.

def page_urls(episode_pages_url):
    """
    Returns a list with all the URLs corresponding to the given episode's pages.
    """
    urls     = [episode_pages_url]
    next_url = lambda url: soup(url).div.a['href']
    page_url = next_url(episode_pages_url)
    while has_manga_page(page_url):
        urls.append(page_url)
        page_url = next_url(page_url)
    return urls

def has_manga_page(page_url):
    html = soup(page_url)
    return not(bool(html.findAll(attrs={'id': 'v'})))

Ahora podemos, dado el nombre de una serie, saber las URL de todas las páginas que contienen las imágenes del manga. Nos queda escribir una función que que encuentre las imágenes que queremos y las descargue.

def download_page(episode_page_url):
    """Downloads the image of the manga page."""
    html        = soup(episode_page_url)
    img         = html.div.a.img['src']
    img_content = urlopen(img).read()
    name        = img.split('/')[-1]
    written_img = open(name, 'w')
    written_img.write(img_content)
    written_img.close()

Ya tenemos todo lo que necesitamos para descargar el último episodio de nuestro manga favorito. Ahora podemos escribir algunas funciones más para completar el script.

def download_episode(episode_pages_url):
    """Downloads the episode located in the given URL."""
    html = soup(episode_pages_url)
    pages = page_urls(episode_pages_url)
    map(download_page, pages)

def create_episode_dir(serie, num):
    """
    Creates a directory with series name, and a subdirectory with episode's number.
    """
    from os import getcwd, chdir, mkdir, path
    serie_dir   = path.join(getcwd(), serie) 
    episode_dir = path.join(serie_dir, str(num))
    try:
        mkdir(serie_dir)
    except OSError:
        pass
    try:
        mkdir(episode_dir)
    except OSError:
        print '>> Looks like you already have downloaded the episode... aborting'
        exit(1)
    chdir(episode_dir)

def download_last_episode(serie):
    num, url    = last_episode(serie)
    create_episode_dir(serie, num)
    pages_url   = episode_pages_url(url)
    if pages_url:
        download_episode(pages_url)
    else:
        print '/!\\ Something went wrong /!\\'


if __name__ == '__main__':
    from sys import argv

    if len(argv) > 1:
        serie = argv[1]
    else:
        exit(1)

    print '>> Downloading last episode of %s' % serie
    download_last_episode(serie)
    exit(0)

Ya podemos descargarnos los últimos capítulos de nuestro manga preferido desde la terminal con este pequeño script.

$ chmod +x submanga.py
$ ./submanga.py Naruto
$ tree -F
.
├── Naruto/
│   └── 566/
│       ├── 10.jpg
│       ├── 11.jpg
│       ├── 12.jpg
│       ├── 13.jpg
│       ├── 14.jpg
│       ├── 15.jpg
│       ├── 16.jpg
│       ├── 17.jpg
│       ├── 18.jpg
│       ├── 1.jpg
│       ├── 2.jpg
│       ├── 3.jpg
│       ├── 4.jpg
│       ├── 5.jpg
│       ├── 6.jpg
│       ├── 7.jpg
│       ├── 8.jpg
│       └── 9.jpg
└── submanga.py

Todo el código está alojado en mi repositorio de scripts en Bitbucket por si queréis usarlo, cualquier comentario o sugerencia es bienvenido, ¡salud!.

Gestionar plugins de VIM con git y pathogen

2011-12-06T00:00:00-08:00

Llevo unos meses utilizando VIM para editar texto, y ningún editor que conozco es tan eficiente y personalizable. En este artículo hablaré de cómo gestiono mis plugins además de otros ficheros de configuración utilizando el sistema de control de versiones git.

Pathogen es un script para VIM que sirve para manipular la variable de entorno runtimepath de forma sencilla. Esto nos permite, además de modificarla para acceder más rápidamente a los directorios que usamos a menudo, tener nuestros plugins en directorios privados para mantener limpio nuestro directorio ~/.vim.

Además, dado que en GitHub hay un mirror de todos los vim-script disponibles en en el sitio oficial de podemos usar la magia de git y pathogen para gestionar todos los plugins que usemos y tenerlos disponibles rápidamente desde cualquier parte.

Lo primero que haremos será crear un nuevo repositorio y guardar nuestra configuración de VIM actual.

$ mkdir plugins-vim && cd plugins-vim
$ git init
$ cp -R ~/.vim ~/.vimrc .
$ git add .
$ git commit -m 'Ficheros de configuración de VIM'

Ahora vamos a hacer uso de una característica de git muy interesante: los submódulos. Un submodulo en git es un repositorio externo que referenciamos desde el nuestro. Una situación en la que puede sernos útil (además de en ésta) es cuando tenemos un proyecto que depende de cierta librería y queremos una referencia al repositorio donde está alojada.

Podemos añadir pathogen como un submódulo pero yo prefiero descargar solamente el script en vez del repositorio completo y guardarlo en ~/.vim/autoload/. Cuando abrimos VIM se ejecutan todos los scripts del directorio autoload.

$ mkdir ~/.vim/autoload
$ curl -so ~/.vim/autoload/pathogen.vim https://raw.github.com/tpope/vim-pathogen/HEAD/autoload/pathogen.vim

Ya tenemos pathogen instalado, ahora sólo nos queda añadir las siguientes líneas al principio de nuestro .vimrc para que añada al runtimepath todos los directorios que hay debajo de .vim/bundle/ y cree la documentación necesaria.

filetype off
call pathogen#runtime_append_all_bundles()
call pathogen#helptags()
filetype plugin indent on

Ya está todo preparado para que podamos tener nuestros plugins en subdirectorios de .vim/bundle y que VIM los cargue. Lo que queda es añadir los plugins como submódulos al repositorio que hemos creado, vamos a hacerlo con uno de los indispensables: NERDTree.

$ git submodule add http://github.com/scrooloose/nerdtree .vim/bundle/NERDTree
$ git submodule init
$ git submodule update

Después de esta secuencia de comandos habremos inicializado y descargado el contenido del submódulo. Ahora vamos a escribir un pequeño script para sincronizar el contenido del repositorio con nuestro directorio ~, lo llamaremos bootstrap.

#!/bin/sh

# descarga la última versión de pathogen
mkdir ~/.vim/autoload
curl -so ~/.vim/autoload/pathogen.vim https://raw.github.com/tpope/vim-pathogen/HEAD/autoload/pathogen.vim 

# descarga la última versión de nuestro repo
git pull --rebase

# descarga la última versión de los submódulos
git submodule init
git submodule update

# sincroniza el contenido del repo con ~
rsync --exclude ".git" --exclude "bootstrap" -av . ~

El script asume que lo ejecutas desde el directorio en el que se aloja el repositorio.

Espero que este artículo te haya servido para organizar mejor tus plugins de VIM. A partir de ahora, cuando estés en un entorno nuevo sólo tienes que descargar tu repositorio, ejecutar el script y tendrás toda tu configuración y plugins de VIM disponibles. Útil, ¿verdad?

Si eres programador y no utilizas VIM te recomiendo que le dediques un poco de tiempo a aprender a utilizarlo, merece la pena.

Crear un blog con Jekyll

2011-12-04T00:00:00-08:00

Voy a escribir un par de artículos para explicar cómo crear y desplegar un blog usando Jekyll. En este artículo cubro la creación de un blog básico.

Jekyll es una herramienta de fuentes abiertas que sirve para generar HTML estático a partir de texto escrito en lenguajes de marcado como Markdown o Textile; además de HTML bruto. Está escrito en Ruby y hace uso de la librería Pygments de Python para el coloreado de sintáxis.

Es simple, ligero y flexible. Hay muchos ejemplos de sitios web que lo usan así que podemos partir del código de uno que nos agrade y modificarlo a nuestro gusto. Este blog que lees está basado en los estilos de Rebase y apenas he tenido que ajustar algunos detalles.

Antes de nada, asegúrate de tener instalados:

Python y pip
Ruby y gem

El código fuente de Jekyll está disponible en GitHub pero por comodidad utilizaremos RubyGems para instalar las gemas necesarias. También nos hace falta la librería Pygments de Python.

$ gem install jekyll
$ pip install pygments

Al instalar la gema de Jekyll se instalarán automáticamente sus dependencias. Jekyll utiliza Liquid para insertar contenido en las plantillas HTML que definimos.

En mi caso la última versión de Liquid me dió problemas con Pygments, la solución fue instalar la versión 2.2.2.

Ahora ya podemos crear el blog. Para empezar creamos la estructura de directorios y los ficheros básicos.

$ mkdir mi_blog && cd mi_blog
$ mkdir _includes _layouts _posts 
$ touch _config.yml _layouts/master.html _layouts/post.html index.html 
$ tree
.
|-- _config.yml       # fichero YAML de configuración
|-- _layouts          # plantillas HTML 
|   |-- master.html
|   `-- post.html
|-- _posts
`-- index.html

El siguiente paso es rellenar el layout que sirve de base para todas las páginas del sitio que hemos creado en _layouts/master.html.

master.html

<!DOCTYPE html>
<html>
  <head>
  <title>{{ page.title }}</title>
  </head>
  <body>
  {{ content }}
  </body>
</html>

Esta es la plantilla base. Hemos introducido los tags {{ page.title }} y {{ content }}, que sirven para inflar de contenido la plantilla.

Antes de rellenar la plantilla para los artículos vamos a escribir index.html y ver cómo se generan los sitios estáticos.

index.html

---
layout: master
title:  Página principal
---
<nav>
  <a href="/about.html">About</a>
  <a href="/atom.xml">Feed</a>
</nav>
<section id="content">
  <article>
    <h2>{{ site.posts.first.title }}</h2>
    <div class="body">
      {{ site.posts.first.content }}
    </div>
  </article>
</section>

Observad que hemos introducido una cabecera en YAML para especificar el layout que vamos a rellenar cuando inflemos esta plantilla. Así, cuando Jekyll crea el fichero index.html estático, hace lo siguiente:

Procesa esta plantilla rellenando los tags de Liquid.

Los tags del tipo {{ site.posts.first.* }} acceden a la variable global site para tomar atributos del primer post e insertarlos en la plantilla.
Infla el layout master con el HTML que ha generado en el paso anterior.

En _layouts/master.html Liquid sustituirá el tag {{ page.title }} por el title que hemos especificado en la cabecera YAML de index.html y {{ content }} por el HTML generado en el paso anterior.

Escribimos la plantilla para los artículos individuales.

post.html

---
layout: master
---
<div class="post">
<h1>{{ page.title }}</h1>
<div class="body">{{ content }}</div>
</div>

Después de crear los layouts, escribimos nuestro primer post. En este caso utilizo el lenguaje Markdown, pero puedes usar Textile o HTML crudo. Los nombres de los artículos siguen la convención año-mes-día-título.lenguaje-marcado así que nuestro primer artículo lo llamaremos 2011-12-04-hola-mundo.md.

2011-12-04-hola-mundo.md

---
layout: post
title:  Hola mundo
---

Este es mi **primer** artículo.

{% highlight sh %}
$ echo "¡Hola mundo!"
{% endhighlight %}

Lo guardamos en el directorio _posts y ya estamos listos para probar el blog. Vamos a modificar nuestro _config.yml para lanzar un servidor localmente y ver los cambios reflejados según vamos trabajando.

# recrea los ficheros estáticos si se modifican
auto:     true
# lanza un servidor al ejecutar Jekyll
server:   true
# permite utilizar el tag highlight
pygments: true

Por defecto Jekyll genera los HTML estáticos en el subdirectorio _site pero podemos cambiarlo en la configuración o al invocar jekyll desde la línea de comandos.

$ jekyll
# jekyll genera los siguientes HTML estáticos
$ tree _site
.
|-- 2011
|   `-- 12
|       `-- 04
|           `-- hola-mundo.html
`-- index.html

Tendremos un servidor en el puerto 4000 sirviendo el HTML estático que ha generado Jekyll y regenerando los ficheros que cambiemos. Abre localhost:4000 en tu navegador favorito y… voilá.

Hola mundo

2011-12-03T00:00:00-08:00

Llevaba tiempo queriendo abrir un blog para escribir sobre programación, compartir enlaces e ideas que considero interesantes y tener un sitio web propio donde expresarme.

Hace unos días descubrí Jekyll, un generador de sitios estáticos escrito en Ruby que me llamó la atención. Es sencillo y muy flexible, y el hecho de poder extenderlo fácilmente mediante plugins escritos en Ruby me animó aún más a usarlo ya que me gustaría aprender el lenguaje.

Después de echar un ojo a unos cuantos blogs generados con Jekyll, copié los estilos de Rebase y aquí está el mío. El favicon lo encontré en Default Icon y los comentarios los he implementado usando Disqus.

En la próxima entrada hablaré de cómo crear un blog como este y desplegarlo fácilmente. Para los impacientes, el código del blog está alojado en Bitbucket.

¡Hasta pronto!