En los últimos posts de este tutorial para desarrollar una aplicación web usando compojure hemos visto cómo crear la aplicación con leiningen y la forma de generar vistas usando Hiccup. En este post empezaremos a dotar de algo de funcionalidad a nuestra aplicación creando el modelo interno que nos permita gestionar la colección de héroes y facts.

Normalmente cualquier aplicación necesita almacenar datos de forma persistente y en clojure existen librerías para emplear todo tipo de bases de datos, pero en este caso vamos a limitarnos a mantener los datos en memoria, lo que nos va a permitir explorar una de las alternativas que ofrece clojure para trabajar con estado mutable: los atoms.

Cómo funcionan los atoms

Como buen lenguaje funcional, clojure promueve el uso de estructuras de datos inmutables, pero hay veces en que no queda más remedio que asumir la mutabilidad. Clojure cuenta con opciones para gestionar la mutabilidad de una forma ordenada, eficiente, y segura desde el punto de vista de la programación concurrente.

Un atom nos permite almacenar información mutable y realizar modificaciones sobre ella garantizando que estas modificaciones se ejecutan de forma atómica. El API básica para manejar atoms es muy simple:

; Para definir un atom se utiliza la forma especial atom
; indicando el contenido del atom (en este caso, un map vacío)
(def my-atom (atom {}))

; Para obtener el valor del atom en un momento determinado,
; se utiliza la función deref o @
(println (deref my-atom))
; => {}
(println @my-atom)
; => {}

; Para modificar el valor de un atom, se usa la función
; swap! indicando la función encargada de calcular el 
; nuevo valor a partir del valor anterior del atom. 
; Por ejemplo, para añadir al map una clave :id 
; asociada al valor 1, usaríamos:
(swap! my-atom (fn [a] (assoc a :id 1))

; O en versión más corta:
(swap! my-atom assoc :id 1) 

; Por último, podemos cambiar el valor del atom sin tener
; en cuenta el valor actual con reset!
(reset! my-atom {:id 1})

La función swap! garantiza que la modificación sobre el valor del atom se ejecuta de forma síncrona y atómica, evitando carreras críticas (race conditions).

El funcionamiento de este sistema se nos queda un poco lejos de este tutorial, pero hay una cosa que debemos tener en cuenta, y es que si se producen conflictos entre dos hebras, la función que pasamos a swap! puede ser ejecutada más de una vez, por lo que deberemos asegurarnos de que es una función pura, es decir, sin efectos colaterales (side effects).

El modelo de la aplicación

El modelo de la aplicación que vamos a crear es muy sencillo. Vamos a seguir la línea habitual en clojure de usar estructuras de datos sin esquema prefijado y almacenaremos la información como un map en el que las claves serán los nombres de los héroes y los valores vectores con los facts.

Usando un atom como los que acabamos de ver mantendremos una referencia a un map con ese aspecto que iremos modificando según se vayan añadiendo nuevos facts a los héroes

Para que todo quede ordenadito, creamos el fichero en ./src/compojure_sample/model.clj con el siguiente contenido:

(ns compojure-sample.model)

(def heroes (atom 
  {"Chuck Norris" 
   ["Chuck Norris no te pisa un pie, sino el cuello."
    "Chuck Norris borró la papelera de reciclaje."]
	  
   "Bruce Scheneier"
   ["Science is defined as mankinds futile attempt at learning Bruce Schneiers private key."
    "Others test numbers to see whether they are prime. Bruce decides whether a number is prime."]

   "Arturo Pérez-Reverte"
   ["Pérez-Reverte se baja música en casa de Ramoncín."
    "Pérez-Reverte no necesita investigar para escribir novela histórica, el pasado cambia conforme teclea en la máquina."]}))

Que me perdonen los puristas pero la tabulación del código clojure todavía presenta algunos misterios para mi.

Puede parecer un poco raro usar strings en lugar de keywords como claves del map, pero cuando integremos esto con la parte cliente en javascript nos va a facilitar la vida.

Suele ser una buena idea encapsular al máximo la parte mutable de un programa funcional, y para ello vamos a crear 3 funciones que nos permitan trabajar con el modelo:

(defn get-facts [hero] 
  (get @heroes hero))

(defn add-fact! [hero fact]
	(swap! heroes update-in [hero] conj fact))
		  
(defn get-heroes []
  (sort (keys @heroes)))

Estas funciones nos permiten obtener los facts de un héroe concreto, añadir un nuevo fact a un héroe y obtener los nombres de todos los héroes para los que tenemos facts registrados. La función add-fact! sigue la convención habitual en clojure de acabar con una exclamación (!) aquellas funciones que modifican estado.

Usando la función get-heroes podemos modificar el handler que usamos para mostrar la página principal del sitio y, en lugar de pasarle a la función que genera la vista un vector con valores hardcoded, obtener los nombres de los héroes de nuestro modelo:

(defroutes app-routes
  (GET "/" [] 
    (view/index (model/get-heroes)))
  ...)

¿Qué nos queda?

Ya nos queda poco para acabar de implementar la aplicación de ejemplo. En el próximo post de la serie veremos cómo exponer una especie de API REST basado en JSON para visualizar los facts asociados a un héroe y añadir nuevos facts.

El código fuente completo de este tutorial lo puedes encontrar en mi cuenta en github: https://github.com/jmhdez/compojure-sample. Siéntete libre de clonarlo, cambiarlo y jugar con él todo lo que quieras, y si te animas a realizar alguna corrección, estaré encantado de recibirla.