Estaba escribiendo en un repositorio de GitHub en el archivo README.org, el resumen de un vídeo de un curso en Python buenísimo que he visto en YouTube. La intención era el poner la imagen del vídeo y debajo escribir un poco el resumen de este, para cuando quisiera acceder a un determinado tema, asociarlo al vídeo y clicar sobre esta imagen para que me lleve a YouTube...

Sigue leyendo el post completo de youtube2org. Añadir la Imagen de un Vídeo de YouTube, en un OrgMode o Markdown

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

Si tu blog comienza a ser muy grande y tienes centenares de tareas en tu Org Mode en estado *TODO*, es muy probable que quieras desmarcar este estado...

Sigue leyendo el post completo de Cambiando estados de forma masiva en mis Org Mode

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

Si tu blog comienza a ser muy grande y tienes centenares de tareas en tu Org Mode en estado *TODO*, es muy probable que quieras desmarcar este estado...

Sigue leyendo el post completo de Cambiando estados de forma masiva en mis Org Mode

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

Años usando Emacs y no ha sido hasta hace unos meses que he descubierto que el buffer de los paquetes, ese al que entramos con M-x list-packages es mucho más fácil de usar de lo que yo pensaba.

Resulta que si te posicionas en la línea de un paquete sin instalar y le das a la i lo marcas para instalar, si vas a uno instalado y le das a la d lo marca para eliminar (delete) y si le das a la U así en general, marca los paquetes que hay que actualizar con una I (upgrade). ¿Y ahora cómo hacemos efectivas estas órdenes? Pues dándole a la x. Así todo lo que queramos borrar se borrará, lo que queramos instalar se instalará y lo que queramos actualizar se actualizará.

En la imagen se ve la I mágica de la que hablo en la columna de la izquierda del todo.

En fin, aquí lo dejo, por si hay otro genio como yo por ahí al que le resulta útil. A cuidarse.

Referencias

48.1 The Package Menu Buffer en el manual de Emacs

Solo del punk no se vive, hoy suenan trompetas.

Existen dos formas de setear una variable en Lisp:

Usando set

Imaginemos que queremos setear una variable que contenga una lista de lenguajes de programación. Podemos hacerlo de la siguiente manera:

   (set 'lenguajes '(c python pascal php java erlang))

Esto setería una variable llamada lenguajes que contendría la lista '(c python pascal php java erlang)

Debemos fijarnos en un par de cosas, una de ellas ya la había explicado en el post anterior.

Si nos fijamos en la lista '(c python pascal php java erlang) podemos ver que la lista comienza con una comilla. Con esto lo que le estamos diciendo al intérprete es que la debe devolver tal y como está, sin evaluar nada.

Por otro lado vemos que hay una comilla simple delante del nombre de la variable. Esto es mas o menos lo mismo, no queremos que la evalúe, solo queremos pasar el elemento a la función set. Si no pusiésemos esa comilla el interprete devolvería un error al tratar de evaluarla.

De esta forma ya tenemos una variable lenguajes que al evaluarla fuera de paréntesis nos devolvería una lista de lenguajes de programación.

Usando setq

Setq es una forma un poco mas sencilla de crear una variable, aunque tampoco mucho mas, ya que lo que nos ayuda setq es en que no tenemos que poner la comilla en la variable que queremos crear. La creación de la variable anterior con setq sería de la siguiente manera:

   (setq lenguajes '(c python pascal php java erlang))

La q de setq es de quoted.

Creando un contador sencillo.

Si usamos set o setq de nuevo sobre una variable que ya tiene un valor asignado este se sobrescribe, así que podemos ver un sencillo ejemplo de esto viendo como podemos definir una variable contador en emacs.

     (setq counter 0) ; inicializador
     (setq counter (+ counter 1)) ; incrementador

     counter ; resultado

El "inicializador" lo que hace como su nombre indica es crear la variable y setearla a 0. Inicializarla. El incrementador incrementa el valor de la variable en 1, así que cada vez que ejecutemos la expresión del incrementador el valor de la variable counter se aumentará en 1.

He comenazado a leerme el manual de introducción a Emacs Lisp, el cual es gratuito y se puede leer online aquí o descargar desde la misma dirección.

Así que voy a ir apuntando por aquí un breve resumen de lo que vaya aprendiendo, aunque no me gusta demasiado como está organizado el libro y voy a intentar solo anotar las cosas que realmente me resulten interesantes o crea que pueden llegar a aportar algo realmente

Listas

Lisp está basado en listas, un ejemplo de lista es el siguiente

     '(rose
       violet
       daisy
       buttercup)

Átomos

Cada uno de los elementos de las listas, separados por espacios en blanco se llama "atom", átomo. En el caso anterior rose, violet, daisy y buttercup serían átomos de la lista. Como buen átomo que se precie no se puede dividir en ningún elemento mas pequeño.

Pocas veces los programadores llaman átomo a los átomos, ya que se suelen referir a ellos por el tipo de átomo que es, por ejemplo string: '("texto entre comillas dobles") el texto entrecomillado con comillas dobles es un átomo de tipo string.

Listas vacías

Así que una lista en Lisp no es mas que una serie de átomos encerrados entre paréntesis. Aunque también podemos tener listas sin átomos, como por ejemplo (). Esto se llama "lista vacía"

Expresiones simbólicas

La representación de átomos o listas es llamada representación simbólica, Symbol Representation también denominada s-expression

Espacios en blanco

Los espacios en blanco no son tenidos en cuenta dentro de una lista, solo se usan como separados de átomos, pero independientemente del número de ellos. Los ejemplos siguientes representan la misma lista:

      '(atom1 atom2 atom3)

      '(atom1
        atom2
        atom3)

      '(atom1          atom2   atom3)

Ejecución de código

Cualquier lista en Lisp es un programa que se puede ejecutar. En la jerga de Lisp: evaluar.

Al evaluar una lista de lisp pueden ocurrir tres cosas:

1. No hacer nada salvo devolver la propia lista
2. Devolver un error
3. Tratar el primer símbolo de la lista como un comando que realiza algo

En los ejemplos en los que hemos visto antes ponía una comilla simple delante de la lista, de está manera: '(lista de elementos) con esto se le dice al intérprete que debe devolver la lista tal cual. En el caso de no poder la comilla el interprete lo que intenta hacer es ejecutar el primer elemento de lista como una función. Como por ejemplo: (+ 2 2) que lo que haría sería sumar 2 + 2, ya que el primer símbolo + es la función de suma en Lisp.

Evaluando expresiones en Emacs

Para evaluar algo en emacs, lo mas sencillo es poner el cursor justo detrás de lo que queremos evaluar y pulsar la combinación de teclas C-x C-e. si por ejemplo tenemos dos listas una dentro de otra o queremos evaluar solamente un elemento de la lista podemos hacerlo colocando el cursor en el punto justo donde deseemos evaluar.

Por ejemplo con la siguiente lista: (+ 2 (+ 3 4)) si evaluamos después del último cierre de paréntesis el resultado devuelto será 9 pero si lo colocamos detrás del penúltimo cierre, el interprete nos devolverá 7 ya que estaremos evaluando solamente la expresión (+ 3 4). Es mas, si evaluamos justo después del 4 nos devolverá 4, ya que los números se devuelven a si mismo al evaluarse.

Generar mensajes de error

En el ejemplo anterior, si evaluásemos el símbolo + nos devolvería un error. Emacs abriría un nuevo buffer donde podríamos ver la descripción del error.

Variables

Para ver el contenido de una variable no debemos meterla dentro de una lista, se debe evaluar fuera de la lista, por ejemplo en el caso de la variable fill-column que viene ya definida en emacs, para ver el contenido deberíamos evaluarla así fill-column. En el caso de que la evaluemos de la siguiente manera: (fill-column) obtendríamos un error, ya que estaría intentando ejecutar fill-column como si se tratase de una función.

Un par de ejemplo de errores serían los siguientes:

Evaluar una variable como una función

    (fill-column)

Esto devolvería un error del tipo:

    ---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function fill-column)
(fill-column)
eval((fill-column) nil)
elisp--eval-last-sexp(nil)
eval-last-sexp(nil)
funcall-interactively(eval-last-sexp nil)
call-interactively(eval-last-sexp nil nil)
command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Se puede ver que dice algo así como que no es una función.

Evaluar una función como una variable

Este es justo el caso anterior, en el que intentamos evaluar una función fuera de una lista, como por ejemplo evaluar el símbolo +

    +

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-variable +)
eval(+)
elisp--eval-last-sexp(nil)
eval-last-sexp(nil)
funcall-interactively(eval-last-sexp nil)
call-interactively(eval-last-sexp nil nil)
command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Sería mas o menos que se intenta ejecutar una variable que no lo es o que no está declarada como tal.

Argumentos

Como en muchos lenguajes de programación, a cada elemento que se le pasa a una función se le llama argumento. El numero de elementos puede ser variable y el tipo de elemento también.

Si pasamos un número de elementos erróneo para una función está devolverá un error. Lo mismo pasará cuando el tipo de argumento no sea el correcto. En el caso del tipado el error devolverá el tipo necesario seguido de "-p", esa p viene de predicate. Por ejemplo si requiere una lista dirá "lisp" si debe ser zero nos dirá "zerop"

La función message

Hay una función en emacs llamada message que sirve para pintar en el buffer de echo del editor. Un ejemplo de su uso sería (message "texto a mostrar")

Conclusión

He decidido no publicar mas en este post, no tiene ni todo el capitulo 1 del libro. Personalmente me resulta un tanto caótico, ya que salta de unas cosas a otras y te mete cosas como por ejemplo la función message cuando está hablando de variables, cosa que no comprendo. Así que lo mismo intento publicar posts un poco mas cortos pero mas centrados.

Hoy os traigo un paquete que exporta tus archivos orgmode a formato html de un modo más bonito y con más calidad ...

Sigue leyendo el post completo de Exportando bonito a html mi OrgMode y creando web estática

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

En artículos anteriores, así como en el Podcast, os he explicado como enviar notificaciones de texto, imágenes y archivos, a través de un Bot en Telegram que podemos crear...

Sigue leyendo el post completo de Notificaciones Org Mode en Telegram con mi Bot

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

Simplenote, es una aplicación de notas muy conocida de Software Libre, totalmente multiplataforma y gratuita...

Sigue leyendo el post completo de Notas y Documentos en la nube para compartir, trabajar en equipo,...

Visita uGeek Podcast

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

Go, también llamado golang, es un lenguaje de programación diseñado por Google. Es de tipado estático, compilado y similar a C. Algunas diferencias con este son que tiene protección de memoria, recolector de basura y concurrencia nativa. Este articulo tiene dos fines, enseñar lo bonico que me ha quedado un programa que he hecho en go y plasmar mis impresiones sobre mi primera incursión en este lenguaje.

Empecemos por el principio. Hace un tiempo decidí que quería hacer un programa que descargase imágenes y las mostrase como una galería en un servidor web tonto. No iban a ser unas imágenes cualquiera, en un principio quería que fuesen los cómics que hace Julia Evans (recomiendo muy fuerte echarle un ojo a su blog). Mediante cómics explica conceptos y herramientas tecnológicas con un estilo muy interesante. Quería poder ver uno de ellos de forma aleatoria, visitando una página web. Me parecía interesante por que hay veces que en el trabajo tengo cinco minutos muertos mientras espero que se ejecute alguna CI, y me parece que aprender cosas que no se suelen buscar es una forma útil de usar ese tiempo.

Tenia pensado hacerlo en python, por que ya he tocado alguna cosilla en flask. El proceso lo tenia claro. Hacia falta un fichero con la lista de las imágenes a descargar. Una vez descargadas, habría que lanzar un servidor web que mediante templates de html, renderizaria una página con las imágenes. Teniendo tan claro lo que habia que hacer, decidí hacerlo en algún otro lenguaje for the lulz.

Go es un lenguaje por el que siento curiosidad desde hace un tiempo. Muchas de las tecnologías que he estado usando el último año están hechas en go, como por ejemplo docker, kubernetes, terraform o prometheus. Y alguna vez me he encontrado algún funcionamiento fuera de lo normal y no he sabido determinar si era un bug o cosa mia, y si hubiese sabido algo de go me habría venido bien.

Como el fin de semana pasado estaba malo y no podía hacer mucho, decidí darle al tema. Y salió gomic.daemons.it.

No entraré en detalles de como se hace nada, porqué el código del programa está muy comentado. De lo que hablaré es de las cosas de este lenguaje que me han llamado la atención (sobretodo en comparación con python) y las cosas que me han gustado del proyecto.

Disclaimer: Mis conocimientos de programación son limitados, por lo que es probable que suelte alguna burrada.

• Lenguaje compilado: Esto lo ves nada más empezar a leer sobre go. Lo que no ves de primeras es que no es necesario compilar. Es recomendable y deberías crear binarios, pero para desarrollar puedes usar go run . y se ejecuta del tirón. Incluso se pueden hacer scripts en go. Hay formas de hacerlo, más o menos estándar, aquí hablan más del tema. Pero si a este script se le da permisos de ejecución y se ejecuta con ./script.go, funciona sin más:

//usr/bin/go run $0; exit
package main
import "fmt"
func main () {fmt.Println("Holi")}

• Declarar tipo de variable VS asignar valor a una variable: No se si es así en otros lenguajes de tipado estático, pero en go se puede hacer de ambas formas:

var variable "holi"
variable := "holi"

• El módulo de logueo: Como se ve aquí, se usa del tirón. Esto es algo que en python siempre me ha molestado mucho, para loguear tienes que hacer movidas muy raras. En go puedes usar log.Println para loguear a nivel info y log.Fatal para errores. Hasta se encarga de parar el programa al haber detectado un error fatal.

• Docker friendly: Una cosa muy interesante que tiene go, a diferencia de java por ejemplo, es que puedes compilar binarios dinámicos o estáticos. La diferencia básica es que el primero solo funcionará en un SO con las mismas características que en el que se ha compilado (es decir, mismas librerías), y el segundo en cualquiera. Mola por que si lo compilas estáticamente, no hace falta nada más. Y cuando digo nada más es literalmente nada más, se puede usar la imagen scratch para crear la imagen. Por comparar, veamos el tamaño de la imagen de drone-xmpp (python) comparado con la de gomic:

r.daemons.it/gomic                   9.24MB
r.daemons.it/drone-xmpp              139MB

Es normal la diferencia. La imagen de gomic solo tiene un binario y un par de htmls, css y js. En cambio la de drone-xmpp tiene alpine, que aún siendo un SO muy pequeño, sigue siendo mucho más que nada.

• Linter chulo: Emacs tiene un paquete de linters llamado flycheck. He intentado sacar como funciona por debajo para dar una visión más general para quien no use emacs, pero no he sido capaz. Si alguien lo sabe, que comente. El motivo por el que me ha gustado tanto es que es capaz de decirte que no puedes asignar la variable a de tipo string al valor 1 por que este un integer. Parece algo como muy tonto, pero me sorprende mucho tener un análisis estático del código en tiempo real y que no consume recursos de forma aparente.

• Control de error obligatorio (casi): Según he visto en muchas de las funciones que he usado suelen obligan a controlar el error. Por ejemplo:

file, err := os.Create(filePath)
if err != nil {
	log.Print("error creating " + filePath)
	log.Print(err)
}

Por que digo que es obligatorio (o casi)? os.Create devuelve la descripción del fichero (file descriptor, creo que se traduce así) y un objeto de error (vacío si no existe). Al devolverlo la función, hay que asignar a ambos valores una variable. Si una variable no es usada en go, el programa no compila. Y ale, de esta forma tan tonta te obligan a tener que hacer algo con esta variable, lo normal seria usarla para comprobar que no hay ningún error. Hay formas de usar la variable para saltarse el bloqueo sin que sea útil, pero la excusa de hacer eso es más bien pequeña.

• repl: Gore es un repl, puedes hacer pruebas rápidas con ello.

• Paquetes nativos muy potentes: Como se puede ver si se lee el código, no he tenido que usar ningún paquete externo para el programa. En un principio usé grab para descargar ficheros, pero realmente no me aportaba demasiado. Además, no dejaba escoger que nombre le ponía al fichero, lo cual es un problema. Pero seguramente lo que llama más la atención es que el servidor http nativo sea tan potente. O igual no es tan sorprendente, si tenemos en cuenta que go se usa mucho para la generación de apis.

• Tipos de datos: Esto fue de lo que más me costó entender, aunque no tengo claro haberlo entendido del todo. Al ser tipado estático, tienes que saber exactamente el tipo de todas las variables, por ejemplo al hacer un return de una función. Me encontré con que no podía convertir estructuras (struct, que se llama) a tipos simples, como es un string o un integer. En realidad no sabia por que no podía, el tema de las estructuras lo descubrí después de muchas horas. Concretamente, lo que estaba haciendo era intentar convertir el tipo os.FileInfo a string. Y claro, no encontraba por internet la forma de hacerlo, por que, salvando las distancias, es como si intentase convertir una clase de python en un string. Sentido cero. Al final era mucho más simple, como solo me interesaba el atributo Nombre, solo habia que acceder al atributo de una forma intuitiva, con os.FileInfo.Name().

• Muy buena documentación: La documentación está muy bien escrita y muchas veces tiene incluso ejemplos.

• Bulma: Esto no tiene que ver con go directamente, pero lo cuento igual por que mola. Cuando hice la primera iteración del programa, la interfaz era esta.

Se lo enseñe a Ameba y como cualquier persona con ojos, se sintió muy ofendida por el “diseño”. Por ello, hizo una primera implementación de bulma, un framework CSS como lo es bootstrap. Viendo que se habia tomado la molestia, por sentido de la vergüenza y por que en realidad soy consciente de que la UX es importante, decidí terminar de implementarlo (con mucha ayuda) y aprender bastante de conceptos básicos de html, css y js, que siempre voy muy pez. Y ha quedado algo más cuqui, como se puede ver en la primera imagen.

Poco más que añadir. Go me parece un lenguaje interesante y probablemente siga aprendiendo porque hace ya tiempo que quiero tener algún otro lenguaje a parte de python. Es improbable que Gomic reciba muchas más actualizaciones más allá de añadir más orígenes, pero cualquier sugerencia siempre será bienvenida.

Me he hartado de usar más de un programa y he decidido que las pocas veces que escriba en LaTeX a pelo lo haré también en Emacs. Así soy, cada día más simple. Para ello estoy usando AUCTeX, un modo hiperpotente que tiene una manual de solo 130 páginas y que se autodefine como un sofisticado entorno TeX para Emacs.

Lo curioso del tema es que instalé AUCTeX hace más de un año porque fue la única manera de hacer funcionar CDLaTeX, el modo menor que ayuda a crear entornos y movidas matemáticas y que uso con Org. En todo este año no he configurado AUCTeX y he seguido usando Texmaker y Kile por pura inercia. Ahora que lo he puesto a mi gusto y que llevo usándolo una semana, he desinstalado el resto de editores de LaTeX y no creo que vuelva atrás, ¡me encanta!

Unas órdenes básicas

Como siempre, para usar AUCTeX hay que instalarlo y activarlo, a mí se me activa solo al abrir un archivo con extensión .tex, pero si no fuera el caso, M-x LaTeX-mode y adelante. Cuidado con confundirlo con latex-mode, el modo para LaTeX que viene con Emacs. Sí, lo hacemos aposta para liar.

Usar AUCTeX es bastante sencillo, hay un par de atajos de teclado que valen para casi todo y que os listo aquí. La palabreja que pongo en cursiva es con lo que yo relaciono la combinación de teclas para acordarme (que puede o no ser la  idea del autor original).

• C-c C-c (compile) ejecuta una orden, dando a TAB podemos ver las opciones, hay opciones molonas como Clean all y Clean que eliminan respectivamente todo lo creado por la compilación y solo los archivos auxiliares.
• C-c C-v (view) muestra el resultado.
• C-c C-e (environment) introduce un entorno y te va pidiendo los datos que necesite.
• Si tenemos el activado el parser automático, con C-c C-a (all) deduce qué tiene que usar y compila las veces que haga falta. No viene activado por defecto porque tarda un poco. Esta historieta nos fabrica una carpeta `auto` con cosas dentro, no os asustéis como hice yo. En el archivo de configuración que he puesto más abajo podéis ver cómo se activa.

Como hereje del Emacs que soy os voy a decir algo: no hace falta aprenderse todo esto. Utilizad la GUI y los menús desplegables sin pudor alguno (yo lo hago, un botón tiene un leoncito muy cuqui).

Embellecedores

AUCTeX tiene herramientas interesantes para que nos resulte más sencillo escribir y entender lo que hemos escrito. Lo que yo llamo embellecedores son sus capacidades de sustituir las letras griegas y otros símbolos con su equivalente Unicode (prettify) y de escribir la letra que está entre etiquetas de formato con el formato en sí (fontify).

Así, cuando escribimos \omega nos pone una ω, si escribimos \emph{cosa en cursiva}, nos escribe el texto en cursiva y demás. Creo que la parte de cambiar la fuente viene activada por defecto pero para los símbolos hay que llamar al modo prettify-symbols-mode.

Tiene además un montón de opciones para previsualizar trocitos de documento, aunque yo no las uso porque estoy muy acostumbrada a escribir en LaTeX y generalmente no la organizo estoy acostumbrada a compilar y mirar los errores en el log por otros editores que he utilizado.

Doblado

Otra cosa que nos ayuda a la hora de leer lo que hemos escrito es el doblado (folding) que consiste en ocultar etiquetas como \section o \emph dejando solamente el texto con el formato.

Si activamos el modo de doblado con M-x TeX-fold-mode y hacemos C-c C-o C-b nos quita el barullo y nos deja un documento mucho más sencillo de leer. Haciendo click o entrando sobre el ítem doblado con el puntero vuelve a mostrarse como LaTeX.

Como esta herramienta me encanta, hago que Emacs me la active siempre cuando uso AUCTeX, más abajo en el archivo de configuración pone cómo lo he hecho.

Autocompletado

Esto ha sido sin duda lo más difícil de configurar, probablemente porque soy una novata del Emacs¹ y pego cosas sin sentido en el archivo de configuración. Después de hurgar en diferentes modos y destruir, me he quedado con la variante para AUCTeX de Company mode que se llama contra todo pronóstico Company AUCTeX.

Para que me funcione tengo que activar  company-mode y luego evaluar (company-auctex-init) así que he puesto eso en el archivo de configuración, probablemente haya maneras mejores.

En fin, dejando a un lado la configuración, esto sirve para que según vayas escribiendo las órdenes Emacs te de sugerencias.

En la imagen se ven además las variables locales que me ha escrito AUCTeX. Ese TeX-master: t significa que este archivo es el archivo maestro, algo muy útil cuando estamos usando subdocumentos, ya que podemos mandar la orden de compilar desde cualquiera de ellos y AUCTeX sabrá cuál es el maestro. Esto me aparece ahí porque le digo en el archivo de configuración que me pregunte la primera vez que compilo cuál es el archivo maestro con (setq-default TeX-master nil).

Otras magias

Este modo hace muchas más cosas, por ejemplo, M-RET al final de línea en un entorno predice lo que necesitamos en la línea siguiente, probadlo en las tablas, vais a ver.

He instalado además el paquete latex-extra para poder abrir y cerrar los títulos como hago en Org.

RefTeX

Estoy usando además RefTeX en combinación con AUCTeX para manejar las referencias y las citas. Este modo lo escribió el creador de Org y es utilísimo para las académicas como yo.

Os pongo un par de atajos que se aprenden rápido por la lógica que se usa generalmente al referenciar en el mundillo (referencias a algo del propio documento entre paréntesis y a la bibliografía entre corchetes):

• C-c = crea un índice que nos permite navegar rápidamente por el documento.
• C-c ( crea una etiqueta (\label)
• C-c ) inserta una referencia (`\ref`) a una etiqueta previamente definida
• C-c [ hace una referencia a una referencia bibliográfica (`\cite`). Dando a la combinación de teclas y escribiendo el nombre de un autor o autora busca en el archivo de bibliografía definido en `\bibliography` y muestra diferentes opciones. A mí al principio me funcionó raro y solo me dejaba buscar la palabra anterior a donde tecleaba la combinación.

Tiene muchas más opciones pero yo tengo un tiempo de vida limitado.

Archivo de configuración

Añadiendo todas las cosas que he comentado, la parte de AUCTeX del archivo de configuración me queda así:

;; Activar CDLaTeX
(add-hook 'LaTeX-mode-hook 'turn-on-cdlatex)
;; Activar prettify
(add-hook 'LaTeX-mode-hook 'prettify-symbols-mode)

;; Autocompletar
(add-hook 'LaTeX-mode-hook (lambda ()(company-mode 1)))
(company-auctex-init)

;; Pide archivo maestro, para documentos con subdocumentos
(setq-default TeX-master nil)

;; Parser automático
(setq TeX-parse-self t) ; activar el parser al cargar
(setq TeX-auto-save t) ; activar el parser al guardar

;; Fold por defecto
(add-hook 'LaTeX-mode-hook (lambda ()(TeX-fold-mode 1)))

;; Activar RefTeX
(add-hook 'LaTeX-mode-hook 'turn-on-reftex)
(setq reftex-plug-into-AUCTeX t)

;; LaTeX extra para tener doblado de secciones como Org
(add-hook 'LaTeX-mode-hook #'latex-extra-mode)

Estoy muy contenta. hay que saber de LaTeX para sacarle partido, pero es maravilloso. Hasta he grabado un minivídeo para que se viesen algunas de las cosas de las que hablo²:

Lo único raro que me ocurre es que no me cierra los paréntesis. Los corchetes, las llaves y los dólares sí, el problema solo es con los paréntesis.

Si fuera perfecto no sería divertido.

Referencias

Manual de AUCTeX

Chuleta de AUCTeX (pdf)

What is your favorite Emacs and/or AUCTeX command/trick? en TeXExchange

Manual de RefTeX

How can I make AUCTeX use the spelling dictionary in the same language as babel is loaded with? en TeXExchange

Useful shortcuts or key bindings or predefined commands for emacs+AUCTeX en TeXExchange

Company AUCTeX

Company mode

Actualización (21/03/2019)

En Vim se puede hacer más o menos lo mismo, tenéis un ejemplo en el flujo de trabajo de este chico para coger apuntes

Sonando este homenaje a Cantona, un futbolista que tiene los nada desdeñables méritos de salir en una película de Ken Loach, decirle a la peña que sacase su dinero del banco para hacer caer el sistema y darle una patada voladora en la boca a un racista.

Emacs es seguramente la tecnología a la que más tiempo de estudio le he dedicado (y dedico) desde que empezó mi interés por los ordenadores. Y si algo he sacado en claro es que, dado mis otros intereses, nunca le dedicaré el tiempo a mi configuración personal que se merece. Lo he hecho durante mucho tiempo y lo seguiré haciendo, pero he decidido que no lo haré “a pelo”, sino que usaré ciertas facilidades que da doom.

Qué es doom? En realidad es la configuración de emacs de hlissner. Este humano quería usar emacs con los atajos de vim y quería que emacs se pareciese a un IDE moderno. Además, decidió que quería que la gestión de este fuese mediante la terminal.

Las características principales que tiene son:

• Un Makefile para gestionar la instalación de paquetes, actualización y otros
• Gestión de paquetes declarativa mediante def-package, un wrapper para use-package y quelpa
• Un gestor de popups mediante shackle
• Atajos de teclado de vim con evil-mode
• Completado de código mediante company-mode
• Gestión de proyectos mediante projectile
• Workspaces mediante persp-mode
• Es bonito
• Arranca rápido (a día de hoy tengo 300 paquetes y ha tardado 4 segundos en arrancar)

Quien ya use estos programas, puede que piense que es una tontería, que no aporta nada. Pero la principal característica, que no mencionan en la página del proyecto es que alrededor de todos estos paquetes mencionados, hay wrappers que hacen que se integren entre ellos. Veremos más adelante a que me refiero.

La característica que más me gusto fue la de workspaces. Ahora solo tengo que ejecutar projectile-switch-project y el proyecto que abra, se abrirá en un workspace nuevo, sin que los buffers que abra se mezclen con los que ya tengo abiertos. Un video vale más que mil palabras.

En este video se puede ver que en el primer workspace, abro el proyecto de mi página web. En el segundo, en cambio, abro uno gestión de infraestructura con ansible. Y ambos están separados, cuando en cada uno de ellos ejecuto find-file, me muestra solo los ficheros de ese proyecto

Para probarlo rápidamente, se puede ejecutar lo siguiente:

git clone https://github.com/hlissner/doom-emacs ~/.emacs.d
cd ~/.emacs.d
cp init.example.el init.el
make install
emacs

En adelante mi configuración estará en este repositorio. Dado que hay muchos cambios respecto a como lo tenia antes, prefiero crear un repositorio nuevo y mantener el antiguo como referencia.

GNU-Linux, Emacs,.. ¿porqué?...

Sigue leyendo el post completo de GNU-Linux, Emacs,.. ¿porqué?

Visita uGeek Podcast

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

Por culpa del Podcast de atareao.es, he estado probando Kde Connect y la verdad es que ha pasado a ser una aplicación imprescindible en mi día a día. Tal como explica en su Podcast, existe la posibilidad de utilizarla con Emacs y como podéis imaginar, no me he podido resistir a probarla. Os explico como utilizarla:

Teniendo los repositorios de Melpa:

1. Instalación: M-x package-install RET kdeconnect
2. Listamos los dispositivos de nuestra red local: M-x kdeconnect-list-devices
3. Buscamos los búfer anteriores para copiar los id de nuestros dispositivos (C-x Izquierda)
4. Introducimos el id de nuestro dispositivo: M-x kdeconnect-select-active-device RET id
5. Hacemos un ping para comprobar que se ha conectado correctamente: M-x kdeconnect-ping

YA ESTA!!!

Ahora si copiamos un texto en el portapapeles de nuestro Emacs, podremos pegarlo en el otro dispositivo gracias a Kde Connect.

Vamos a enviar un texto desde Emacs al otro dispositivo M-x kdeconnect-ping-msg RET Texto

Os dejo el resto de funciones para que juguéis y el repositorio donde está toda la información:

Resto de Funciones disponibles

Repositorio de GitHub

Publicado por Angel

Suscribete al Blog

Suscribete al Podcast

Canal en Telegram

Grupo en Telegram

uGeekPodcast en Twitter

YouTube

Escucha más Podcast en el Reproductor de la web ►Play

Tags: , blog , emacs , kdeconnect ,

Vamos a convertir nuestros archivos Markdown a Org Mode gracias a Pandoc. Para ello, primero necesitamos instalar Pandoc en nuestro Ubuntu:

sudo apt install pandoc

Ahora tenemos 2 posibilidades, transformar únicamente un archivo .md a .org, o aprovechando la magnífica gestión de los archivos Org Mode, convertir todos los archivos Markdown de una carpeta a un único archivo Org Mode.

1) Markdown a Org Mode. Ejecutamos este comando en la terminal.

pandoc -f markdown -t org -o nuevo_archivo.org archivo_a_convertir.md

2) Muchos archivos Markdown a un único Org Mode.

Vamos a la carpeta donde están todos los Markdown que queremos convertir y Llamamos a find vía Pandoc:

find . -name \*.md -type f -exec pandoc  -f markdown -t org -o {}.org {} \;

Recordar verificar que la conversión se ha hecho correctamente.

Publicado por Angel

Suscribete al Blog

Suscribete al Podcast

Canal en Telegram

Grupo en Telegram

uGeekPodcast en Twitter

YouTube

Escucha más Podcast en el Reproductor de la web ►Play

Tags: , blog , emacs , markdown , orgmode , pandoc ,

Sincronización Selectiva en Syncthing, Markdown en Emacs, Blog Jekyll, Escritorio i3...

Sigue leyendo el post completo de Sincronización Selectiva en Syncthing, Markdown en Emacs, Blog Jekyll, Escritorio i3

Visita uGeek Podcast

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

sucede que haciendo una prueba con el vps conectado via ssh queria dejar corriendo un comando

> youtube-dl -f best -ciw -v 'https://www.youtube.com/channel/UCbGYYbuGLFC6wIsyKXXW4cQ'

y salir de la sesion, dejando al vps a su bola, p-e-r-o, p-e-r-o, p-e-r-o si sales de la sesion ssh, tu comando tambien se corta

y esto no se soluciona poniendo un & al final del comando, por que este (supongo y sin idea) “proceso” es un “hijo” de tu shell que es un hijo de tu sesion y si la sesion se muere, el padre mata a todo mundo. Ja, ja, ja, ha

Como solucionar esto? pues teniendo un shell que sea “hijo de un demonio😈” que ande a su bola, e invocarlo cuando nos venga en gana

y todo esto que suena tan complicado y misterioso, es mas facil de lo que parece (creo). Encima podemos hacerlo con emacs, aunque igual, segun la situacion podriamos recurrir a otros dos programitos habitualmente disponibles en cualquier distribucion

emacs

emacs tiene un modo demonio que sirve para dos cosas:

• cargar emacs una vez y luego lanzar instancias que comparten la misma sesion pero se manifiestan a la velocidad del rayo

• volver independiente tu sesion de una shell, fuera esta en ssh o en modo texto o grafico

primero, para activar el modo demonio lanzamos el siguiente comando

> emacs --daemon

esto no lanzara ningun emacs, simplemente colocara bajo las sombras una sesion con la que podremos contactar. Para hacer esto necesitamos un comando particular llamado emacsclient. Como la mayoria de las cosas, no es tan sencillo. Si lo lanzamos tal cual

> emacsclient
emacsclient: file name or argument required
Try 'emacsclient --help' for more information

nos dira que intentemos ver la ayuda. Si bien, esta ayuda es basta, podriamos simplificarla a dos opciones utiles

> emacsclient -c

que nos lanza emacs en el buffer scratch.

dejemos una marca en dicho buffer para identificar nuestros pasos. Colocando por ejemplo, la frase "hola soy emacsclient uno"

bien, terminemos emacs como se haria habitualmente C-x C-c e invoquemos de nuevo a nuestro emacs-demonio emacsclient -c -nw

hala, nuestro mensaje sigue hay!

ahora en nuestra terminal (tilix) dividida, lanzamos de nuevo emacsclient -c -nw

de nuevo lo mismo

y si cerramos uno o todos los emacsclient da igual, lo que en ellos hagamos permanecera mientras no se apague el sistema o cerremos el modo demonio

la otra forma en la que podemos lanzar emacsclient, consiste en indicar que ficheros abrir

> emacsclient fichero1 fichero2 ...

y ahora con esto, podriamos resolver el problema inicial. Abrimos una shell, ponemos el comando a ejecutar, salimos (C-x C-c), cerramos el ssh y regresamos cuando lo creamos conveniente. El demonio de emacs con todos sus buffers y demas cosas, seguira realizando su labor!

y ahora? pues para terminar con el modo demonio, desde un emacsclient

M-x server-mode

nos dira que actualmente hay un servidor con clientes, que si lo queremos terminar de todas maneras, a lo que diremos que si.

cosas

emacs es un entorno centrado en el texto, que puede dividirse, expandirse y adaptarse de formas inimaginables, sin embargo, una terminal pura donde ejecutar programas visuales e interactivos escritos cada uno en su lenguaje, con sus propias librerias y forma de entender sus combinaciones de teclado, igual y queda en otra liga mas alla de los fines de emacs

tambien, aunque emacs posee su propia terminal (tonta) eshell, lo mejor es lanzar programas no interactivos. Ademas eshell, sola hay una y solo una, Emacs no es multiproceso, o hace una cosa o hace otra, pero no dos al mismo tiempo. Si lo que necesitamos son varias shell reales, lo mas conveniente seria recurrir a otras herramientas

GNU Screen

esto es un multiplexor de terminal, que segun la wikipedia:

es una aplicación de software que puede utilizarse para varias sesiones de inicio de sesión independientes basadas en seudoterminales dentro de una única pantalla de terminal, una ventana de emulador de terminal, una consola de sistema de PC/puesto de trabajo o una sesión de inicio de sesión remota, o para separar y volver a adjuntar sesiones de un terminal. Es útil para tratar con múltiples programas desde una interfaz de línea de comandos, y para separar programas de la sesión de la shell de Unix que inició el programa, particularmente para que un proceso remoto continúe ejecutándose incluso cuando el usuario está desconectado.

pero que en resumidas palabras, podria resumirse en un “emacs” para las terminales o como “un entorno de escritorio para las terminales”

y que podemos hacer con esto? tras instalar gnu screen (buscarlo como screen en su distribucion) y lanzarlo por primera vez

> screen

nos resivira con un bonito mensaje

tras presionar espacio, aparecera el prompt de nuestra shell de siempre, donde lanzar los comandos de siempre

bien no? pues si… a-u-n-q-u-e, cuando salimos de la terminal, no salimos de la terminal, saldremos de la terminal en screen

[screen is terminating]

volvamos a lanzarla de nuevo y veamos como demonios (ja, ja, que cachondo) utilizar este invento

primero, screen tiene algunas influencias emacseras, y como este, tiene un prefijo para hacer cosas, que por defecto es C-a (Control y a al mismo tiempo) seguido por una (o mas) combinaciones que serian el comando en si, por ejemplo, si presionamos C-a d saldremos de screen pero sin cerrar screen, que seguira en “segundo plano” a su rollo, rollo al que podemos regresar

como hacer esto? no es tan sencillo, primero deberemos averiguar el nombre de nuestra “sesion” y re-enlazar a ella

mientras haciamos el C-a d nos lanzaba la siguiente salida

[detached from 6469.pts-3.tachikoma]

un dato similar podemos obtenerlo con el siguiente comando

> screen -ls
There is a screen on:
	6469.pts-3.tachikoma	(Detached)
1 Socket in /run/screens/S-nasciiboy.

donde el dato importante es ese que va luego del punto del numero, hasta el primer espacio, es decir (y en este caso particular) pts-3.tachikoma. Dicho valor nos servira para recuperar la sesion

> screen -x pts-3.tachikoma

bonito no? ehhhh, mas o menos. Salgamos sin cerrar e iniciemos una nueva sesion con un nombre mas sencillo

> screen -S mi-sesion

de nuevo, tendriamos otra terminal…

repitiendo el listado de sesiones

> screen -ls
There are screens on:
	7832.mi-sesion	(Detached)
	6469.pts-3.tachikoma	(Detached)
2 Sockets in /run/screens/S-nasciiboy.

guaaa, que emocionante…

para contactar a esta nueva sesion

> screen -x mi-sesion

y? pues ahora un par de cosas medio chulas, primero podemos dividir la pantalla ¡en dos! presionando C-a S

luego puedes saltar a esta nueva division con C-a TAB. Ver el cursor en esta nueva seccion, apretar los botones a lo loco y ver que no pasa nada

hasta que invoques una shell en este espacio con el comando magico C-a c

dividir nuevamente la ventana (ahora en vertical) C-a |, saltar a esta C-a TAB, nueva shell C-a c y sonreir locamente

ahora como cerrar este conjunto, si salimos de la shell (C-d o con exit) la seccion no desaparecera, seguira hay hasta que presionemos C-a X

…

si por alguna razor quisieramos cambiar el prefijo C-a por otro distinto, por ejemplo C-b, tenemos dos opciones crear un fichero .screenrc en nuestro home con el contenido

escape ^Bb

con lo que el comando prefijo quedaria fijado a C-b por siempre jamas, o bien, lanzar screen de la siguiente manera

> screen -e^bB

y pocas cosas mas puedo comentar sobre screen y sus fabulosas cualidades. Para mas informacion dentro de la misma sesion presionar c-a ? invoca a la ayuda. tambien podriamos ver la pagina del manual

tmux

y… tmux es mas o menos como screen, tambien va a su rollo y puede sobrevivir al cuelgue de una sesion ssh, tiene combinaciones “tipo emacs” y sirve de “entorno de escritorio para las terminales”, p-e-r-o, p-e-r-o, p-e-r-o, por defecto es algo mas amigable y 🌈moderno🌈 (1987 vs 2007) aunque ambos estan escritos en c

y cual escogeria screen o tmux? pues, tmux! aunque si hay necesidad, se usar los dos!

y ahora, como usarlo

> tmux

como vemos, a diferencia de screen, tmux se nos comera una fila al final de la pantalla, muy a lo emacs. Otra diferencia particular, empieza por el prefijo, que en lugar de ser C-a pasa a ser C-b (y encuentro mas comodo). Ademas de eso al dividir la pantalla en sus diferentes formas

• C-b " division horizontal
• C-b % division vertical

aparecera una shell sin hacer nada mas

podemos deambular por las “divisiones” con

• C-b o saltar a la siguiente
• C-b ← saltar a la derecha
• C-b ↑ saltar arriba
• C-b → saltar a la derecha
• C-b ↓ saltar abajo
• C-b C-← redimencionar hacia la derecha
• C-b C-↑ redimencionar hacia arriba
• C-b C-→ redimencionar hacia la derecha
• C-b C-↓ redimencionar hacia abajo

tambien centrar la atension en la shell actual sin romper la distribucion de las ventanas con C-b z (zoom) y luego restaurar con otro C-b z

o incluso y mas locochon, hacer que las shells cambien de sitio con C-b C-o

o hacer aparecer un reloc ascii gigante con C-b t

u otras cosas mas chulas como agregar “nuevos escritorios” con C-b c

e ir y venir entre escritorios con

• C-b n siguiente
• C-b p anterior
• C-b 0, C-b 1 C-b …, escritorio 0, escritorio 1, …

o C-b w, que nos permite elegir visualmente

salir de esta secion sin cerrarla con C-b d y recuperarla con tmux attach

tambien, podriamos no salir de dicha sesion e ingresar en ella desde otra terminal, repitiendo tmux attach

que hace una cosa muy chula; adaptarse y limitar lo que se ve en la sesion con las dimenciones de la mas pequeña. Ademas, como en screen podemos darle un nombre a una sesion y vincularnos a ella

> tmux new-session -s mi-sesion # lanzar
> tmux attach -t mi-sesion      # conectar
> tmux list-sessions            # listar sesiones

esto y muchas cosas mas que pueden o no ser de interes, empiezan consultando la ayuda incluida C-b ?, su pagina man o si se desea un librillo con comentarios

https://leanpub.com/the-tao-of-tmux/read

aunque creo que el nombre “the tao of” le viene grande, pues no enseñan un flujo o estrategia de trabajo. Solo comandos con imagenes, que puedes descubrir por tu cuenta, como el obscuro proceso para congelar la pantalla, seleccionar texto y pegarlo en donde se nos ocurra aun sin sesion grafica!

en fin, yo estoy utilizando tmux para dejar corriendo en el servidor comandos de prolongado tiempo y tambien para ejecutar weechat “acumulando logs” por dias y dias en salas de irc… mera investigacion de la fauna…

happy hacking!

Hace un tiempo que dejé de usar php+-mode, mas que nada porque parece que lo han sacado de Melpa y me gusta tenerlo todo actualizado, así que decidí volver a php-mode, un modo que no usaba ya que php+-mode me parecía mas completo.

En php+ tenías proyectos donde podías configurar muchas cosas, como por ejemplo los tests, cosa que con php-mode no se puede, el tema es que para lo de los proyectos hace mucho que uso projectile, un modo imprescindible para programar, pero me faltaba la integración de phpunit. Por suerte tenemos phpunit.el una libreía con la cual podremos ejecutar nuestros tests.

Yo he tenido que añadir alguna cosa en mi configuración que no viene en la documentación oficial, como por ejemplo que coja el ejecutable de phpunit de una ruta de mi carpeta, si vosotros lo tenéis en el path del sistema no creo que tengáis problemas.

Pues bien, esta es toda la configuración que he tenido que añadir a mi fichero de configuración:

  (use-package phpunit
    :ensure t
    :config
    (add-hook 'php-mode-hook (lambda ()
                             (setq phpunit-default-program (concat (projectile-project-root) "bin/phpunit"))
                             ))
    )

Esto es lo que hace la configuración:

• Hace que use-package se descargue el modo y lo instale. Si no usáis use-package deberíais echarle un ojo porque es bastante útil.
• Añade un hook para que cuando entremos en modo php saque la ruta del ejecutable de phpunit usando la ruta del proyecto en el que nos encontramos.

Esto último me dio algunos problemas, ya que no se me había ocurrido ejecutarlo en el hook y se ejecutaba en la propia configuración, que al estar versionada con git pues también la tengo como proyecto.

Con esto ya podremos usar las funciones del modo phpunit, que podréis encontrar en su documentación. Lo suyo es que os las asignéis a alguna combinación de teclas, yo tengo que F2 me ejecute el test en el que me encuentro posicionado y F3 me ejecuta todos los tests de la clase.

  (global-set-key[f2] 'phpunit-current-test)
  (global-set-key[f3] 'phpunit-current-class)

Los tengo globales, porque es como los usaba en php+-mode, es algo que aún tengo pendiente de cambiar, en esos refactors infinitos que hacemos durante toda nuestra vida en la configuración de emacs.

Recursos

• GitHub - nlamirault/phpunit.el: Emacs mode to phpunit and test command line tool

Una de las cosas que siempre he tenido ganas pero me ha dado mucha pereza ponerme a hacer ha sido configurar el correo para gestionarlo a través de emacs. Hace un par de días decidí dar el paso, hoy lo he estado probando y ha merecido la pena el esfuerzo

Aquí están todos los pasos que he tenido que dar para configurar una cuenta de Gmail en Emacs y en Debian.

Offlineimap

Lo primero que necesitamos es un cliente de imap. Este cliente será el que se encargue de actualizar nuestra cuenta de gmail, sincronizando los cambios entre nuestro local y el servidor de Google. Para eso he instalado offlineimap

sudo apt-get install offlineimap

Después de descargar el programa debemos configurarlo de la siguiente manera, comenzaremos creando un fichero de configuración en: ~/.offlineimaprc

El contenido del fichero es el siguiente. Esta es la configuración básica que he encontrado en los ejemplos, de aquí deberemos cambiar el usuario del email, en el ejemplo está como usuario@gmail.com. Importante fijarse que está en dos lineas.

También podremos cambiar la carpeta donde queramos que se descargue el correo. El password como podéis ver no está añadido, ese es el siguiente paso.

[general]
accounts = Gmail
maxsyncaccounts = 1
pythonfile = ~/.offlineimap.py

[Account Gmail]
localrepository = Local
remoterepository = Remote

[Repository Local]
type = Maildir
localfolders = ~/Maildir

[Repository Remote]
type = Gmail
remoteuser = usuario@gmail.com
remotepasseval = get_password_emacs("imap.gmail.com", "usuario@gmail.com", "993")
realdelete = no

folderfilter = lambda foldername: foldername not in ['[Gmail]/Spam', '[Gmail]/All Mail', '[Gmail]/Starred', '[Gmail]/Important']

holdconnectionopen = true
keepalive = 60
sslcacertfile = /etc/ssl/certs/ca-certificates.crt

Para no tener que guardar el password en texto plano en nuestra configuración de offlineimap debemos crear un par de ficheros mas y hacer alguna cosilla. Empezaremos por crear un fichero ~/.offlineimap.py con el siguiente contenido dentro:

#!/usr/bin/python
import re, os

def get_password_emacs(machine, login, port):
    s = "machine %s login %s port %s password ([^ ]*)\n" % (machine, login, port)
    p = re.compile(s)
    authinfo = os.popen("gpg -q --no-tty -d ~/.authinfo.gpg").read()
    return p.search(authinfo).group(1)

Del fichero .py no hay que tocar nada, simplemente se encarga de leer un fichero que crearemos ahora donde se encontrará la contraseña.

El siguiente paso es crear el fichero ~/.authinfo, en este fichero deberemos introducir lo siguiente, cambiando usuario@gmail.com por nuestro usuario y aquivaelpassword por nuestra contraseña.

machine imap.gmail.com login usuario@gmail.com port 993 password aquivaelpassword
machine smtp.gmail.com login usuario@gmail.com port 587 password aquivaelpassword

Y ahora viene el encriptado del fichero, ya que si lo dejamos así estaría en texto plano.

El cifrado lo realizaremos desde emacs, ejecutando el siguiente comando y seleccionado el fichero .authinfo que acabamos de crear.

M-x epa-encrypt-file

Esto nos generará un fichero ~/.authinfo.gpg, una vez creado debemos eliminar el original.

Y con esto ya tenemos configurado nuestro imap lo siguiente sería sincronizar con el siguiente comando y tomarnos algo mientras tanto, porque tardará bastante.

$ offlineimap

¿Qué pasa si tengo doble factor de autenticación en mi correo?

Posiblemente tendréis habilitado un segundo factor de autenticación en vuestra cuenta, en ese caso no podréis usar vuestra contraseña, para solucionar eso tenemos dos opciones:

• Crear una aplicación Oauth en Google y usarla con offlineimap. Esta opción no la he probado, así que no se como se haría, si que he visto algún post comentando como se hace.
• Crear un pasword de aplicación para el correo electrónico desde vuestra cuenta de google y usarlo como password. Aquí teneis como se realiza.

He visto quien desaconseja esta última opción ya que sería como quitar el doble factor de autenticación y recomiendan usar el token de Oauth. Mi impresión es que estaríamos en las mismas, ya que el password de aplicación tiene también la opción de cancelarlo y así invalidar esa aplicación.

Posible error con gpg

Al ejecutar todo el proceso en otra máquina me encontré con el siguiente error a la hora de ejecutar offlinimap: gpg: Sorry, no terminal at all requested - can't get input

La solución mas sencilla que he encontrado ha sido cambiar en el script de Python gpg por gpg2. Quizás antes tengais que instalarlo, en Debian sería con apt-get install gnupg2 y habría que dejar el script ~/.offlineimap.py de la siguiente manera:

#!/usr/bin/python
import re, os

def get_password_emacs(machine, login, port):
    s = "machine %s login %s port %s password ([^ ]*)\n" % (machine, login, port)
    p = re.compile(s)
    authinfo = os.popen("gpg2 -q --no-tty -d ~/.authinfo.gpg").read()
    return p.search(authinfo).group(1)

Creando el indice

Una vez ya ha terminado offlineimap de sincronizar debemos indexar, para ello nos hará falta mu, como también nos hará falta mu4e lo instalamos e indexamos.

sudo apt-get install mu4e

mu index --maildir=~/Maildir

Cron

Lo siguiente que he hecho y que mas me ha costado encontrar es como hacer estas tareas cada X tiempo, no por que sea complejo si no porque no he visto nada relacionado. Yo he decidido crear un cron que lo ejecute cada 5 minutos.

crontab -e

Y como contenido:

*/5 * * * * offlineimap -u quiet && mu index --maildir=~/Maildir

Envío de correos

Para envíar los correos desde emacs hace falta instalar lo siguiente en Ubuntu/Debian

sudo apt-get install gnutls-bin

Configurando Emacs

Aún no he tocado demasiado, estoy aún aprendiendo el modo mu4e, así que esta configuración es opcional. Dejo aquí la mía como ejemplo.

Imap

       (require 'mu4e)

       ;; default
       (setq mu4e-maildir (expand-file-name "~/Maildir"))

       (setq mu4e-drafts-folder "/[Gmail].Borradores")
       (setq mu4e-sent-folder   "/[Gmail].Enviados")
       (setq mu4e-trash-folder  "/[Gmail].Papelera")

       ;; don't save message to Sent Messages, GMail/IMAP will take care of this
       (setq mu4e-sent-messages-behavior 'delete)

       ;; setup some handy shortcuts
       (setq mu4e-maildir-shortcuts
             '(("/INBOX"             . ?i)
               ("/[Gmail].Enviados" . ?s)
               ("/[Gmail].Papelera"     . ?t)))

       ;; allow for updating mail using 'U' in the main view:
       (setq mu4e-get-mail-command "offlineimap")

       (setq
        user-mail-address "usuario@gmail"
        user-full-name  "Nombre Apellido"
       )

SMTP (envío)

    (require 'smtpmail)

    (setq message-send-mail-function 'smtpmail-send-it
          starttls-use-gnutls t
          smtpmail-starttls-credentials
          '(("smtp.gmail.com" 587 nil nil))
          smtpmail-auth-credentials
          (expand-file-name "~/.authinfo.gpg")
          smtpmail-default-smtp-server "smtp.gmail.com"
          smtpmail-smtp-server "smtp.gmail.com"
          smtpmail-smtp-service 587
          smtpmail-debug-info t)

Alertas

Nos pintará en nuestra barra un sobrecito con el número de correos sin leer, lo ejecutará cada minuto y además mostrará alertas del sistema.

  (use-package mu4e-alert
    :ensure t
    :after mu4e
    :init
    (setq mu4e-alert-interesting-mail-query
      (concat
       "flag:unread AND maildir:/INBOX AND NOT flag:trashed "
       ))
    (mu4e-alert-enable-mode-line-display)
    (defun gjstein-refresh-mu4e-alert-mode-line ()
      (interactive)
      (mu4e~proc-kill)
      (mu4e-alert-enable-mode-line-display)
      )
    (run-with-timer 0 60 'gjstein-refresh-mu4e-alert-mode-line)
    )

Como podéis ver este código por ahora es prácticamente copiado y pegado de las fuentes, como he dicho aún no he tenido tiempo de tocarlo demasiado y quizá tampoco me haga falta.

mu4e

Pues poco puedo contar de este modo, aún tengo que aprender a manejarlo bien. Si ejecutáis en emacs M-x mu4e os mostrará un pequeño dashboard donde podréis comenzar a usarlo, con documentación incluida.

Conclusión

Solo llevo un día de uso y me ha resultado muy útil, sobre todo para hacer limpieza de correos. Me costó un poco configurarlo todo, pero una vez conseguido ha merecido mucho la pena.

Una recomendación que me gustaría daros es que no uséis gmail, en este caso lo hice porque es el correo del trabajo, podéis usar cualquier correo que acepte IMAP y SMTP y seguramente con algún protocolo mas también. Os dejo con un listado de servicios y herramientas que si tienen en cuenta la privacidad del usuario, ahí podréis encontrar buenos servicios de email.

Cualquier duda puedes preguntarme por gnusocial.net.

Fuentes

• A Complete Guide to Email in Emacs using Mu and Mu4e
• Manage your email in emacs with mu4e · GitHub

Recuerda, “No tiene que gustarte Emacs para que te guste”––Emacs puede tener diferentes colores, diferentes comandos y diferentes atajos que el Emacs por defecto. {AItPiEL}

An Introduction to Programming in Emacs Lisp

git clone https://gitlab.com/nasciiboy/elipo.git
# o
git clone https://notabug.org/nasciiboy/elipo.git

para descarga en formato zip, tar, o bien visionar directamente en version web en ingles y español

“Una introducción a la programación en Emacs Lisp” es una guia turistica por los conceptos basicos de la programacion, recorriendo las entrañas mas emblematicas en “las fuentes” de GNU Emacs, el “editor extensible”.

El documento es un primer acercamiento gentil, mas o menos claro y muy reiterativo a Emacs Lisp, que a un iniciado en la programacion deseoso por utilizar el verdadero potencial de emacs le vendra de maravilla. Menciono que a un iniciado, por que asi es mi caso, y me costaria recomendarlo como primer libro de programacion. Aun asi, utiliza buenas analogias e introduce los conceptos base de forma tan gradual como para no descartarlo (por completo) como libro novel.

A lo largo del material, aprenderemos ademas de los fundamentos de la programacion (variables, bucles, recursividad, funciones, …, listas), a crear atajos personalizados para las funciones de Emacs, como tambien a definir las nuestras propias, a manipular y construir listas lisp, visitar buffers, mover el punto, utilizar la region, crear funciones interactivas, a conocer el anillo de la muerte y en ultima instancia a enterarnos con certeza de lo que hacemos con nuestro init.el…

…bueno, el texto esta un poco anticuado fue escrito con la version 22 (2007-2008) en mente, pero en la practica (practicamente) todo el codigo aun es aplicable, exeptuando algunas pocas funciones y configuraciones relacionadas con X Window

Antes ya habia realizado otros acercamientos a lisp como “The land of Lisp” (traduciendolo “informalmente” como hasta un 2X%) y tambien con ANSI Common Lisp, pero este ha sido el primer libro que termino y donde (mas o menos) llego a comprender las bases de Lisp… sin masterizarlo a profundidad, pues el libro no abarca conceptos como la metaprogramacion, macros y el potencial de las funciones lambda (quien sabe que signifique todo eso…)

De momento Lisp me continua pareciendo un lenguaje curioso, con algo de elegancia (no demaciada), medianamente “retro” y un poco tosco en lo que a adquirir documentacion y uso de librerias se refiere

Muchos aspectos son forzados a encajar en el molde de las listas y en otros tantos, como las “formas especiales”, simplemente se ignoran en pro de la practicidad

Mi calificacion?

• No es una perdida de tiempo

• Necesario si quieres profundizar en emacs o descubrir la superficie de lisp

• Sin ser una lectura ipnotizante, tampoco es soporifera. En ocaciones cuesta seguir las ideas del autor, pero es apreciable que sin ser un escritor de profesion o vocacion (supongo) se esforza por plasmar su conocimento lo mas claro que le fue posible

porg

No recuerdo si fue en alguna busqueda de Emacs-material, en irc o directamente el la pagina de David Arroyo donde con alegria incontrolable descubri la existencia de una traduccion al español (en apariencia terminada) de este titulo, que ademas de tener una version en PDF y texinfo, contaba con el material impreso.

Con la mayor alegria que puede albelgar un aprendis del silicio y en particular usuario de Emacs que poco entiende del lenguaje ingles, procedi a descargar el PDF para recorrerlo con deseo. Sin embargo, al poco de leer, fue evidente que la version tenia defectos apresiables aun para un completo perdido del engrish.

Incredulo, supuse que la version digital y la impresa tenian algun (compresible) desfase comercial y fui directamente al repositorio donde se albergaba la fuente. Para descubrir que el material era tal cual el del repositorio

No negare que un fuerte sentimiento de desilucion aparecio al ver que habria que hecharle esfuerzo para tener un material compresible. Aunque viendolo desde otro angulo, ya habia personas que habian invertido tiempo y energia preparando el material. Que menos que unirse a la causa para sumar al material, o tan siquiera dejarlo en un punto que fuera util a mis egoistas fines

Segun el repo, la primer contribucion que hice fue el 30-05-16, pero aunque intente mantenerme constante, encontre que traducir mediante un fichero .po que ademas esta documentado en texinfo es bastante engorroso. Sumado a esto, las taras ortograficas y traductorias que cargo que son bastas (e incorregibles…), como resistirme a colocar acentos o a pasar un corrector ortografico y ademas tener en esas fechas algunos experimentos bizarros para un lenguaje de marcas ligero que cumpliera todas mis ridiculas exigencias, condujeron a que hiciera un “fork” del proyecto

“fork” etre comillas, porque no cargue con el material original. Fue una adaptacian express al lenguaje experimental de aquel tiempo (aun sin exportador, ni nada) y tras “corregir” cerca del 30% perdi la motivacion….

el asunto se fue aparcando, el formato de marcado ligero cambiando y poco interes tenia por actualizar

hasta que por diciembre del 2017 lo retome esporadicamente y luego de bastantes seciones, pues lo doy por “usable” y digno de ser compartido bajo unos pobres estandares.

Eso si, no sera ningun logro literario, pero no negare que visualmente tanto las versiones web y en morg, tienen un acabado de puta madre. Ha quedado bien chido y “profecional”

Sin embargo, la parte de la traduccion que no se como inicio, pero creo fue obra del traductor de google (y en un inico continue con la tradicion hasta que aparecio deepl) (por mi parte) consistio apenas en darle sentido a los parrafos

En muchas (por no decir que en todas) las seciones, terminaba por entrar en una face cercana al sueño y dejando presionada una tecla indefinidamente. Iniciaba una alerta de regresar a la consciencia, y… volvia a controlar la somnolencia, unos minutos mas antes de desistir.

Otro de los bellos detalles que inclui, fueron palabras con sus caracteres en posiciones alteradas de sitio. Asi como palabras repetidas y poca atencion al formato

Hay varios sitios donde es necesario hacer mas digerible la transmicion de ideas y otros donde por la falta de conocimiento del engrish solo intuia el sentido e inventaba el resto

Algunas traducciones no son consistentes, otras dificiles de transladar y unas mas se asume que ya se entienden, por ejemplo las funciones y conceptos narrow y widen, que deje como reducir y extender

Donde decia “computer” al principio substitui con computador, pero termino como ordenador, y asi otros tantos detalles

Por el lado del codigo, el proyecto de traduccion original (de libre-manuals) planeaba adaptar el codigo a una version reciente. Por parte mia, y ya que segun la wikipedia el autor de esta obra (y otras mas) Robert J. Chassel murio en 2017, he preferido dejarlo (casi en su mayoria) tal cual. (Alguna cosa cambie pero no recuerdo que exactamente.)

Otra cosa importante, es que todas las regiones de texto en el original dentro de un bloque texinfo ignore, las extripe de las versiones a “morg”. Considere que eran comentarios y ya que estaban inconclusos los quite.

…

Asocia la tecla ‘Bloq Mayus’ a ‘Control’ (Una interfaz de usuario tan rota, sugiere que los fabricantes de teclados piensan que las computadoras son máquinas de escribir de 1885.) {AItPiEL}

Y luego del momento de monolo, el producto central esta en los siguientes repos

git clone https://gitlab.com/nasciiboy/elipo.git
git clone https://notabug.org/nasciiboy/elipo.git

tambien hay uno en github, pero los repos hay presentes (todos inconclusos) los he congelado y/o estan en proceso de migracion hacia gitlab

Para quien desee intervenir el material, recomendaria primero leer acerca del (cambiante y experimental) lenguaje de marcas ligeras morg y si se quiere profundizar mas, seguir la etiqueta morg en este blog.

El fichero donde deben realizarce las modificaciones tanto en español, como en ingles es emacs-lisp-intro_es.porg

Para facilitar la labor, utilizo org-mode para algunas funcionalidades, como escribir listas y tener outline-mode. Algunas de las configuraciones que se pueden agregar a init.el para ayudar un poco, son:

(add-to-list 'auto-mode-alist '("\\.morg\\'" . org-mode))
(add-to-list 'auto-mode-alist '("\\.porg\\'" . org-mode))

;;; resaltado primitivo y no siempre certero de la sintaxis
(add-hook 'org-mode-hook
          (lambda ()
            (highlight-regexp "@[^[<({]+[[<({][^]>})]+[]>})]" 'hi-green-b)
            (highlight-regexp "@[[<({][^]>})]+[]>})]" 'hi-red-b)
            (highlight-regexp "@[^[<({]+[[<({][]>})]" 'hi-red-b)
            (highlight-regexp "[[:space:]]@[[:space:]]" 'hi-yellow)
            (highlight-regexp "@[a-zA-Z]+[[:space:]]" 'hi-yellow)
            (highlight-regexp "^ *@ +.*" 'hi-pink)
            )
          )

me parece que el programa que esta en los repositorios y el que utilizo en mi sistema para realizar la exportacion, difieren un poco… estaba en proceso de refactorizacion e inesperadamante cai en un bucle de poscastinacion y falta de ideas.

En los planes esta que las versiones finales de ficheros (en|es|..|xx|).morg puedan mesclarze, traducirse automaticamente, compararse, reformatearse y demas. Pero ante mi ineficacia, para este material recurri a simples trucos para generar la versiones finales apartir del fichero .porg

para producir la traduccion en español, solo tienen que borrarse todas las lineas que inicien con #. Para generar la version en ingles, mantener todas las lineas vacias y que inicien con #, y luego eliminar el # inicial mas un caracter en blanco (si lo hubiera)

he colocado unas cripticas instrucciones en el .porg, para generar ambas versiones.

De .porg a en.morg y ademas exportacion a html, seria:

awk 'length == 0 || /^#/' emacs-lisp-intro_es.porg | sed -e 's/^# \?//' | sed '8,11d' > emacs-lisp-intro.morg && morg toHtml emacs-lisp-intro.morg

y de .porg a es.morg con exportacion a html:

morg unPorg emacs-lisp-intro_es.porg && morg toHtml emacs-lisp-intro_es.morg

Si se desea verificar que los enlaces en las exportaciones html apuntan a algun lado, se puede utilizar linkchecker (presente en los repositorios de debian)

linkchecker emacs-lisp-intro_es.html --check-extern

algunas convenciones

cuando despues de un atajo se incluye el nombre de la funcion que invoca “entre parentesis”, utilizo la sintaxis @%c(nombre-de-funcion)

cuando despues de un palabro en español o ingles se coloca su equivalente en el otro idioma, utilizo la sintaxis @%i(traduccion/original)

En el documento origital varias “piezas de codigo” se colocaban entre comillas simples. Cuando lo considere pertinente y que ofrecia un mejor resaltado utilice @'c(pieza-de-codigo)

Por falta de mejora en el exportador, y sombretodo, como un apaño, dentro de los bloques de codigo, deben respetarse los espacios en blanco. Si un bloque de codigo en el original tiene una linea de espacio en blanco, debe intercaralse forzosamente el codigo en ingles, colocando la traduccion al español y que ambos bloques compartan la linea en blanco

En el original, habia condiciones para que al exportar el fuente los enlaces externos a los manuales de Emacs y Emacs Lisp estubieran accesibles desde info y en caso de exportar en un formato diferente, desde la ruta web.

un proposito futuro, es replicar este comportamiento (una vez adaptadas esas dos obras a morg), pero eso puede tardar mucho o nunca suceder. Para mantener la funcionalidad, en principio substitui toda referencia a dichos recursos con la ruta web al manual mono-pagina. Pero para evitar peticiones de varios megas a gnu.org, con la lentinud que ello conlleba, termine por colocar en el repositorio verciones locales de estos en formato web mono-pagina

En el original creo que las citas con comillas dobles y sencillas y ---, se aplicaban mediante sintaxis texinfo. Para mejorar la legibilidad en el fuente, se modificaron a “cosas”, ‘cosas’y ––. El formato morg, tiene comandos para aplicar los mismos efectos: @"(cosas), @'(cosas) y @-(cosas). Sin embargo el ultimo no esta adaptado para casos “especiales” si las cosas tienen llave de apertura pero no de cierre. Aun considero cambiar todas las apariciones “legibles a simple vista” por su version en comando, pero no lo termino de decidir

Disfrut! Bienvenidas las peleas, asesorias programacionales a morg, los exportadores de texinfo a morg, los tenedores, monitores 2K y sobre todo, el sucio dinero!

¡He aprendido a cambiar la fuente de Emacs! Y no solo eso, sino que he conseguido que sea diferente según el sistema operativo en el que nos encontremos.

Todo esto ha venido porque la fuente por defecto de Emacs en Windows no me diferenciaba los ceros y la letra O y los unos y la L minúscula y me estaba volviendo loca. Aprovechando que en Matlab me había pasado a Consolas, decidí que de ahora en adelante usaría Consolas al estar en Windows (es una fuente propietaria pero que viene incluida en Microsoft Office). En GNU/Linux he seguido con la que se establecía por defecto¹, Roboto Mono, que aunque la creó Google, lleva licencia Apache.

Como yo quería que Emacs eligiera la fuente según el sistema operativo, necesitaba averiguar primero cómo le llamaba Emacs a mi sistema operativo. Esto puede conseguirse evaluando la variable system-type, o bien con M-x eval-expression o con M-:. Así supe que esta variable toma el valor de windows-nt en Windows y gnu/linux en GNU/Linux. Algo totalmente inesperado dicho sea de paso.

Bien, ahora me faltaba averiguar cómo cambiar la fuente y crear un if. Lo primero es simple, solo hay que añadir cualquiera de estas líneas al archivo de configuración:

;; Establecer fuente
(set-face-attribute 'default t :font FUENTE :height TAMAÑO)
;; Establecer familia de fuentes
(set-face-attribute 'default t :family FAMILIA :height TAMAÑO)

El if tampoco es mucho más complejo, solo hay que tener en cuenta que tiene miles de paréntesis:

(if (condición)
(Expresiones si se cumple la condición)
(Expresiones si no se cumple la condición))

Fusionando ambas cosas me quedó esto:

;; Fuente
(if (eq system-type 'windows-nt)
    (set-face-attribute 'default nil :family "Consolas" :height 110)
    (set-face-attribute 'default nil :family "Roboto Mono" :height 110)
)

Evidentemente se puede mejorar añadiendo una condición de que use la fuente correspondiente solo si está disponible o de otras manera diversas que ahora no se me ocurren pero a vosotros sí porque sois muy listos. La cuestión es que hurgando un poco se puede conseguir casi cualquier cosa en Emacs y por eso me encanta.

Ale pues, os dejo, ¡contadme cosas en los comentarios!

Referencias

How to determine the operating system in elips? en StackOverflow

Emacs: Font Setup en Ergo Emacs

38.3 Operating System Environment en el manual de Emacs

37.12.1 Face Attributes en el manual de Emacs

Sonando:

Por lo habitual, mi uso de Emacs va emparejado con una terminal y auxiliado por el navegador de ficheros (y firefox). Asi que lo mas conveniente seria poder sincronizar las rutas de trabajo entre Emacs, Tilix (terminal) y Nautilus (navegador grafico de ficheros) sin tener que escribir cada vez la ruta entera, o andar pinchando con el raton en botones visuales

la solucion (quitando el glamour de la frace “sincronizar las rutas de trabajo de …“) consiste simplemente en copiar la ruta actual de cada programa al portapapeles

tilix

la eleccion de este emulador de terminal (ademas de por su gnomero estilo y su personalizacion de atajos profunda) se encuentra fundamentada en incorporar marcadores de fabrica. Sin embargo, optener la ruta actual y copiarla directamente al portapapeles no es una de sus caracteristicas… y por ello la solucion puede aplicarse a cualquier emulador de terminal.

para saldar la limitacion usaremos el programa xclip (buscar en el repositorio de su distribucion), en conjuncion con pwd y tr (para eliminar el salto de linea producido por pwd)

pwd | tr -d '\n' | xclip -sel clip

el comando se explica por si mismo…

otro comando que tambien suelo utilizar habitualmente para “ajustar” las fechas en los post de este blog:

date --iso-8601=seconds | tr -d '\n' | xclip -sel clip

si bien, el recordar estos comandos a primera vista parece (y lo es) una meta imposible, ya que utilizo fish como interprete y como este se encuentra en modo historial permanentemente, solo tengo que ingresar o pwd o data y el solito se encarga de completar el comando. De esa forma evito crear un script especifico para copiar cosas entre el terminal y el resto del entorno grafico

nautilus

pues nada, aunque tiene sus marcadores, si se presiona la combinacion C-l nos muestra y selecciona la ruta actual… Copiar, modificar o pegar!

Emacs

los marcadores en emacs, ademas de diferenciarlo del resto de la “competencia” lo convierten en un asistente muy potente. La cuestion es como comunicar las rutas de trabajo con el portapapeles del entorno

La solucion mas sencilla es entrar en modo dired para seleccionar y matar la ruta actual, y como la ultima entrada en el anillo de la muerte tiene comunicacion directa con el cortapapeles, tendriamos resuelto el problema… pero, ya que emacs se puede adaptar a nuestras necesidades, extendamos su funcionalidad para que copie directamente en el clipboard tanto la ruta de trabajo, como la ruta del buffer actual

(defun pwd-to-kill-ring ()
  "Agrega la ruta actual al kill-ring."
  (interactive)
  (kill-new default-directory))

(defun buffer-path-to-kill-ring ()
  "Agrega la ruta del buffer actual al kill-ring."
  (interactive)
  (if (buffer-file-name)
      (kill-new (buffer-file-name))
    (message "El buffer actual no esta ligado a un fichero")))

(global-set-key "\C-cp" 'pwd-to-kill-ring)
(global-set-key "\C-cf" 'buffer-path-to-kill-ring)

listo! con unas modificaciones minusculas tenemos nuevas funcionalidades y atajos vinculados a estas. C-c p para optener el pwd y C-c f (si el buffer actual esta vinculado a un fichero) para optener la ruta absoluta a la fuente del buffer, o en su defecto un amigable mensaje “El buffer actual no esta ligado a un fichero”

(mencionar que emacs posee el comando cd con el que podemos modificar manualmente el pwd al que apunta, como tambien un comando nativo pwd. Este pwd cambia automagicamente segun el buffer en el que estemos)

ido-mode

como el shell fish tiene un sistema de autocompletado de rutas automagico (fusionado con el historial), emacs no podia ser menos y deberia proveernos ayuda con el autocompletado de las rutas.

el modo ido nos proporciona autocompletado con “busqueda difusa” de patrones y esta disponible para la busqueda de ficheros, directorios y buffers

de inicio, es un poco lioso y si presionas tap sin antes ver que es lo que hace ido puedes verte creando ficheros en rutas inesperadas. Uno llega a cogerle el truco, pero en ultima instancia es posible desactivar sus “ayudas”

ido forma parte de la distribucion estandar, asi que no tenemos que instalar nada, solo configurarlo un poco

(require 'ido)                    ; invocar a ido
(setq ido-enable-flex-matching t) ; activar busqueda difusa
(ido-mode t)                      ; activar ido

con esto (hasta donde he podido percatarme) ido usurpara el lugar de los comandos vinculados a C-x C-f, C-x d, C-x C-d, C-x i, C-x C-w y C-x b.

Para utilizarlo basta con escribir tap para completar automagicamente y usar las flechas derecha e izquierda para navegar entre las opciones.

No hara falta escribir el nombre preciso del siguiente elemento en la ruta, con escribir algunos caracteres, por ejemplo la extencion de lo que buscamos, seguramente sea suficente.

en caso de que queramos desactivar ido y regresar temporalmente al comando que este suplantando, basta con presionar C-f. Si con esto no es suficiente y se desea apagar ido pues M-x ido-mode, o siendo mas radical, (mientras nos habituamos) podemos vincular su activacion/desactivacion a un atajo

(global-set-key (kbd "C-c .") 'ido-mode)

compile

la mayoria de los programas que realizan algun tipo de inspeccion en un fichero, como pueden ser compiladores, exportadores de formatos o programas de busqueda de patrones, suelen lanzar resultados con el formato

ruta-de-fichero:linea: "cosas"

o

ruta-de-fichero:linea:columna: "cosas"

el comando compile de emacs, se aprovecha de esta convencion para permitirnos navegar entre los ficheros que indique nuestro programa, de una forma mas comoda de lo que seria buscar directamente a mano el fichero, su linea y columna.

cuando se invoca al comando compile (M-x compile) nos pedira un comando (del sistema) a ejecutar, este podria ser por ejemplo gcc mis-cosas.c, make o por que no, grep!

Para buscar todas las coincidencias en una ruta!

M-x compile RET grep -Rn patron [ruta-opcional]

(M-x compile RET grep -Rn package ~/nconf/emacsRocks/)

sorprendente!

para navegar, entre las coincidencias podemos cambiar entre ventanas (C-x o) y dar enters en las lineas resaltadas, o, presionar C-h m y averiguar que combinaciones trae por defecto compile.

ja, ja, ja, aunque la utilidad del comando es evidente, a los peresosos emacsers les da mas por laborar una vez y descanzar eternamente. Por ello tenemos dos modos disponibles para hacer busquedas “a lo grep”.

El primero viene incorporado y se llama occur, vinculado a M-s o. El inconveniente es que las busquedas se limitan al buffer actual.

El segundo, basa su funcionalidad en un (nuevo) comando del sistema llamado ag (The Silver Searcher) que es algo asi como un grep super rapido, configurado para actuar recursivamente por defecto

hay un modo para unir en armonia tanto a compile como a ag para ello (como recomiendan en su repositorio) tendriamos que clonar el fuente y agregar lo siguiente a nuestro init:

;; source: git clone https://github.com/philsnow/ag.el
(add-to-list 'load-path "~/ruta/a/carpeta/ag.el")
(require 'ag)
(setq ag-highlight-search t)

para utilizar el comando: M-x ag RET patron RET ruta

… y eso es todo, happy hacking!

Este miércoles 25 de abril, a las 20:00, daré una charla sobre emacs en la Brecha Digital. Veremos, a grandes rasgos, qué es exactamente emacs, sus orígenes, comparación con vim para darle emoción, que posibilidades de uso tiene y cómo empezar a usarlo. El nivel de la charla será introductorio, pero si ya conoces emacs siempre puedes aprovechar la ocasión para ver la Brecha Digital, un grupo que se reúne en La Brecha, un centro social alquilado, en el que nos untamos habitualmente para dar charlas y aprender tecnologías molonas en común. Más información de La Brecha Digital aquí, echadle un ojo para ver como llegar a La Brecha.

Para programar en PHP me gusta usar el modo mayor php+-mode y uno de los modos menores que uso es ac-php para usar company-mode y realizar el autocompletado. Este modo menor es bastante útil, sobre todo porque crea una tabla de tags muy buena, pero no he encontrado una forma automática de crearla, cada cierto tiempo ejecutaba el comando de generación de tags para autocompletar.

Tenía previsto desde hace mucho tiempo hacer que se regenere cuando guardo un buffer en modo php+ pero por pereza lo he ido dejando, incluso asigné una tecla al comando de tags, pero al final me decidí a hacer las cosas bien.

Actualizando tags de PHP cuando guardo un fichero en modo PHP

Este es el código que finalmente he añadido a mi configuración, a continuación os lo explico.

   (defun remake-ac-php-tags ()
   "Remake php tags from current buffer"
   (when (eq major-mode 'php+-mode)
      (ac-php-remake-tags))
    )

   (add-hook 'after-save-hook #'remake-ac-php-tags)
   

Como veis lo primero que hago es crear una función que será la que lanzaremos con el hook, podría decirle al hook que lanzase directamente la de generación de tags, pero la que he creado también filtra por el modo en el que nos encontramos.

(when (eq major-mode 'php+-mode) (ac-php-remake-tags))) Aquí está lo interesante, la condicion que dice que el modo mayor debe ser php+-mode y dentro la ejecución del comando que deseamos.

(add-hook 'after-save-hook #'remake-ac-php-tags) El siguiente paso ya es simplemente añadir la función al hook que se lanzará siempre que se guarde un fichero.

Al final el código es sencillo a mas no poder, es mas la pereza de buscar el cómo se hace, que el hacerlo. Espero que os sirva de ayuda a la hora de lanzar vuestras acciones al guardar un fichero.

Debería mejorarlo para que en realidad mirase si está el modo menor ac-php activo, pero la verdad es que aún no se como hacerlo.

es muy vergonZoSo sentirse capaz y al enfrentar un reto quedarse congelado al borde del fracaso

El asunto es el siguiente, tenemos un fichero con correos (muchos correos, 79 exactamente). El fichero ademas de los correos incluye nombres y comas y la meta es obtener unicamene los correos.

Empece el reto substituyendo comas por saltos de linea, luego probe una complicada regexp para buscar los correos, pero tras muchos fallidos intentos, abandone la idea… ademas, que esperaba encontrando la regexp? no es como si la coincidencia colocara la region en la coincidencia y luego se pudiera “cortar” y “pegar”

Lo siguiente, fue utilizar el comando flush-lines para borrar las lineas que no coincidieran con el patron [^@], “obviamente” no funciono, auque en mi ignorancia culpe al patron… (risa histerica) y bueno, sucede que no te aclaras y hasta se te olvida utilizar la ayuda del emacs

un par de intentos mas tarde, termine por utilizar una poco elegante macro, que cumplia el objetivo chapuceramente

luego, tras ver la primer solucion, mas simple, conpacta, no del todo “segura”, pero para el caso efectiva

cat lista_correos.txt | tr " " '\n' | grep @ | xargs

e inmediatamente despues un vi-liever solucionaba el asunto con

:%s/  */^M/g
:v/@/d
:%join

como podia evitar la inminente culpa y herida en el orgullo klingon-emacsero?

intetentando superar la frustracion, dio inicio un aprendizage formal y profundo de las regexes en emacs y alguno que otro comando mas. Pero antes de pasar a ello, fue nesesario aminorar el trauma implementando una solucion en awk y otra en C….

# esto a un fichero, por ejemplo a.awk
1 {
    for( i=1; i<=NF; i++ )
        if( $i ~ /@/ ){
            printf( "%s\n", $i)
        }
}

# y luego ejecutar con:
# $ awk -f a.awk lista_correos.txt

aca la solucion con C. Compilar con gcc a.c regexp4.c y ejecutar con $ a.out lista_correos.txt

Un dia despues, con la agonia mental aun fresca, llego la solucion en emacs

M-<
M-x replace-regexp RET " +\|," RET C-o RET
M-<
M-x keep-lines RET "@" RET

(no conocia keep-lines si tu tampoco, te la presento. Ignorar las comillas son para delimitar la cadena de entrada)

ciertamente mas extensa que vi, pero consideremos que emacs no tiene una simbiosis con el comando sed, ni tampoco una implementacion de sus comandos de tal forma que puedan ejecutarse “en bloques”. No esta tan mal, supongo.

aqui es donde se podria iniciar una “guerra santa”. Pero bueno, la naturaleza extensible e ilimitada de emacs para un tema concreto puede ser menos eficiente, es cierto… aunque, nada impide que se implemente un comando interprete tipo sed e incluso otro para aplicar acciones por lineas y de manera global (sin recurrir a macros)

Supongo que los usuarios del modo maligno, han hecho algo asi, mas profanar emacs con tales paganismos, ni utilizar “modos” que fuerzan a presionar ESC de forma inconciente, son algo a contemplar por mi parte, las cosas “modales” son un dolor, ya es suficientemente modal tener que usar el firefox, o el navegador de ficheros y andar presionando ahi teclas de otros “modos”

o, por aca un semi-equivalente en elisp de la solucion

(defun emailtor ()
  "Separa los correos en lista_correos.txt"
  (interactive)
  (goto-char (point-min))
  (while (re-search-forward " +\\|," nil t)
    (replace-match "\n" nil nil))
  (goto-char (point-min))
  (delete-non-matching-lines "@"))

ha, no es lo mas fino, pero para el caso cumple

regexp

• Conjunto []. Conjunto inverso [^]. Dentro de los conjuntos (con la syntaxis completa [[:clase:]]) se permiten las clases

  • [:alnum:] caracter alfanumerico
  • [:alpha:] una letra, incluidos caracteres unicode
  • [:blank:] espacio y tabulacion
  • [:cntrl:] caracteres ASCII de control
  • [:digit:] numeros ascii del 0 al 9
  • [:graph:] cualquier caracter visible, exepto espacios en blanco
  • [:print:] cualquier caracter visible, incluidos espacios en blanco
  • [:lower:] caracteres en minusculas
  • [:upper:] caracteres en mayusculas
  • [:punct:] signos de puntuacion
  • [:space:] espacios en blanco
  • [:word:]caracteres que formen parte de las palabras
  • [:xdigit:] caracteres hexadecimales (0-9, a-f y A-F)
  • [:ascii:] caracter ASCII
  • [:nonascii:] cualquier caracter no ASCII
  • [:multibyte:] caracteres unicode multibyte
  • [:unibyte:] caracteres codificados en un solo byte (basicamente todo ASCII)

• punto .

• metacaracter \

• agrupacion y captura \(\)

• coincidencia con la anterior captura \d. (Substituir d por el numero de captura)

• agrupacion sin captura \(?:\)

• alternativa \|

• cuantificadores

  • ? cero o uno
  • * cero o mas
  • + uno o mas
  • \{n\} exactamente n
  • \{n,\} n o mas
  • \{n,m\} entre n y m

• modificadores

  • $ coincidencia al fin de linea
  • ^ coincidencia al inicio de linea
  • \= coincidencia en la posicion del punto
  • \' coincidencia al final del buffer
  • \` coincidencia al inicio del buffer

• fin o inicio de palabra \b

• (deacuerdo al modo) un caracter que forme palabras \w o \sW

• (deacuerdo al modo) un carac,ter que no forme palabras \W o \Sw

• espacios \s- o \s (”\s”)

• symbolos \s_

• delimitador de apertura \s(

• delimitador de cierre \s)

• caracteres de puntuacion \s.

comandos de utilidad

• (search-forward) busqueda de texto hacia adelante

• (search-backward) busqueda de texto hacia atras

• C-s (isearch-forward) busqueda de texto de forma interactiva hacia adelante

• C-r (isearch-backward) busqueda de texto de forma interactiva hacia atras

• (search-forward-regexp) busqueda de regexp hacia adelante

• (search-backward-regexp) busqueda de regexp hacia atras

• C-M-s (isearch-forward-regexp) busqueda de regexp de forma interactiva hacia adelante

• C-M-r (isearch-backward-regexp) busqueda de regexp de forma interactiva hacia atras

• M-s o (occur) listado interactivo de lineas que coinciden con la regexp

• (replace-string) substitucion de texto

• (replace-regexp) substitucion de regexp

• M-% (query-replace) substitucion interactiva de texto

• C-M-% (query-replace-regexp) substitucion interactiva de regexp

• (highlight-lines-matching-regexp) resaltar cualquier linea que coincida con una regexp

• (highlight-regexp) resaltar una regexp

• (unhighlight-regexp) des-resaltar regexp

• (flush-lines) eliminar lineas que coincidan con la regexp. (el patron ^$ eliminara todas las lineas en blanco)

• (keep-lines) se eliminan las lineas que no coincidan con la regexp

• (align-regexp) alinea (verticalmente la parte en varias lineas que coincida con la regexp

re-builder, isearch, isearch+

De entre las muchas cosas relacionadas con regexes, el modo re-builder es uno muy interesante, pues nos permite escribir y editar una regexp con suma facilidad y luego copiar el resultado.

Supongo que este modo, es una facilidad para los programadores de emacs, basandome en que la expresion esta entrecomillada y al copiar la regexp con el comando reb-copy (C-c C-w) incluye las comillas y ademas el formato de escape de caracteres esta dispuesto a la forma que requiere el codigo fuente en elisp.

Dicho escape de caracteres y metacaracteres, se debe a la naturaleza de las cadenas en C de hay que las cosas suelan requerir escapes para los escapes. Por defecto re-builder viene en modo de syntaxis read que es de la que hablo, pero tambien podemos cambiar a sintaxis string (la que utiliza isearch), bien presionando la combinacion C-c TAB y escribiendo string o directamente colocando lo siguiente en nuestra configuracion

;; re-builder
(setq reb-re-syntax 'string)

pese a la facilidad de edicion y creacion de regexes, me pregunto la razon de no vincular este modo con isearch. Mas adelante (o no) una posible razon y un par de soluciones.

los comandos basicos de utilidad

• C-c C-w copiar regexp (comillas incluidas)
• C-c C-q salir del modo
• C-c TAP cambiar syntaxis de entrada
• C-c C-r ir a coincidencia previa
• C-c C-s ir a coincidencia siguiente

isearch en sus modalidades mas conocidas isearch-forward-regexp (C-M-s) e isearch-backward-regexp nos permiten buscar expresiones regulares hacia adelante y hacia atras del punto interactivamente, mas no dejeis que os engañen las funciones basicas de estos comandos, pues no son simples comandos, son modos por si mismos, podemos averiguar sus muchas posibilidades (ya dentro de isearch) presionando C-h m o con la documentacion de la funcion C-h f isearch-forward-regexp

quiza el comando mas conocido de las busquedas interactivas sea C-w que toma la entrada sobre y delante del punto como texto de entrada (dividida por palabras). Pero ademas de esa combinacion tenemos otras muy interesantes

• M-s e para editar “con papeles” la regexp, aunque no interactivamente
• C-M-y ingresar a la regexp el caracter del buffer sobre el que esta el punto
• C-M-w borrar el ultimo caracter de la regexp
• M-s C-e ingresar a la regexp el resto de la linea apartir de la posicion del punto
• C-y traer ultima cadena del anillo de la muerte
• M-y iterar sobre el contenido del anillo de la muerte
• M-c cambiar la sensivilidad a las mayusculas-minusculas
• C-s siguiente coincidencia
• C-r anterior coincidencia

y muchas otras cosas misticas y confusas mas trae el modo. La cuestion problematica tiene que ver con la forma en que isearch incorpora el contenido del anillo de la muerte a la busqueda, pues si por ejemplo matamos la cadena \(group\)[set] al hacer el yank (C-y) en lugan de ingresar \(group\)[set] escapara los caracteres significativos en la regexp, dejando \\(group\\)\[set] lo que obligaria a editar de forma penosa la expresion

preguntando en reddit, el unico lugar donde aparecen respuestas prontas y en ociones con feliz resultado, oantolin proporcionaba el siguiente comando alternativo para hacer el yank con su contenido tal cual dentro de la expresion

(defun isearch-yank-kill-literally ()
  "Pull string from kill ring into search string literally."
  (interactive)
  (setq isearch-yank-flag t)
  (let ((string (current-kill 0)))
    (isearch-process-search-string
     string
     (mapconcat 'isearch-text-char-description string ""))))

(define-key isearch-mode-map (kbd "C-S-y") #'isearch-yank-kill-literally)

como puede verse, se sugiere la vinculacion al atajo Control-Super-y, pero en mi caso me es incompatible con otro comando… lo que sirvio fue suplantar directamente el comando yank de isearch dejando como nombre de la nueva definicion solamente isearch-yank-kill

cabe aclarar, que la copia tal cual del contenido del anillo de la muerte, no es una caracteristica considerada de inicio en isearch, por lo que al hacer un M-y, el demas contenido del anillo seguira siendo modificado con escapes. De hay que otro colega, 00-11, suguiriera el uso del modo isearch+, que si considero esta necesidad en su base

isearch+ (supongo) es una capa sobre el modo isearch que ademas de agregar la posivilidad de hacer yanks sin modificar el contenido, nos colorear la busqueda en secciones y proporciona varios comandos de utilidad extra. Todo esto manteniendo los atajos de isearch (casi) intactos

isearch+, no viene en el repositorio melpa, para instalarlo deberemos copiar directamente su codigo desde emacswiki a un fichero, y luego cargarlo “a mano”.

https://www.emacswiki.org/emacs/download/isearch%2b.el

En el mismo fichero proponen cargar el modo con el comando

(eval-after-load "isearch" '(require 'isearch+))

pero he preferido agregar lo siguiente en mi init

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE*: isearch+            ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; source: https://www.emacswiki.org/emacs/download/isearch%2b.el
(load-file "~/.emacs.d/plugins/isearch+.el")

vamos con la justificacion de utilizar isearch+, que era poder hacer yanks.

En la linea 2547, tenemos la variable customizable isearchp-regexp-quote-yank-flag que si la ponemos a nil, asi

    (defcustom isearchp-regexp-quote-yank-flag nil

nos dara el resultado que buscamos.

Si, se puede hacer el cambio de la varible en el init, pero ya que tenemos y vamos a cargar el codigo directamente, mejor dejarse de historias y hacer el cambio in-situ

(nota: al cargar isearch+ substituye automaticamente a isearch. He probado el modo con emacs 25 sin ninguna extencion y funciona sin problemas)

ahora si, despues de tener isearch+ configurado, podemos escribir nuestra funcion en re-builder (modo de syntaxis string) y copiar la regexp (manualmente) ignorando los parentesis, para luego “pegarlo” directamente en isearch(+) con un yank

Enlaces, fuentes y otras cosas

• http://ergoemacs.org/emacs/emacs_regex.html
• https://ondahostil.wordpress.com/2017/10/21/lo-que-he-aprendido-expresiones-regulares-en-emacs/
• https://www.emacswiki.org/emacs/RegularExpression
• https://www.gnu.org/software/emacs/manual/html_node/elisp/Syntax-Class-Table.html#Syntax-Class-Table
• https://www.gnu.org/software/emacs/manual/html_node/emacs/Search.html#Search
• https://www.reddit.com/r/emacs/comments/8aepnk/yank_text_in_isearch_without_escape_character/

Post original (04/12/2001) -> https://www.linux.com/news/emacs-vs-vi-endless-geek-holy-war

Vi: ¿El editor que el tiempo olvidó?

Más es más con EMACS?

¿No podemos llevarnos todos bien?

He empezado a usar Magit. Tanto escuchar Magit es el mejor modo para git jamás creado y yo empecé a usar Emacs por Magit me han convencido a darle una oportunidad. Eso y que el modo git normal que usaba no me carrula bien en el ordenador del curro (¡Windows!).

La cuestión es que Magit me flipa, puedo manejar mi repo desde Emacs solo dando a un par de teclas y ayudando por tanto a mis pobres bracitos lesionados por el ordenador.

Lo más curioso de este modo es que funciona a base de ventanitas (pop ups) en las que se nos dan opciones diversas. A cada ventanita se accede con una tecla y podemos acceder a la ventanita de las ventanitas con h (help). Cada ventanita se divide en dos pedazos, en la parte superior activamos las opciones y en la inferior elegimos el comando. No os preocupéis que enseguida lo veremos todo mucho más claro.

Por cierto, si como yo usáis Emacs con GUI y menús (¡sacrilegio!) tendréis en la barrita un menú de Magit con las diferentes órdenes y sus teclas correspondientes.

Lo básico: status, add y commit

Empezamos a usar Magit en un repositorio existente diciéndole que nos muestre el estado del mismo en una de sus ventanitas con la siguiente orden:

M-x magit-status RET

La ventanita de estado

La documentación nos aconseja asignarle la combinación de teclas C-x g a este comando ya que lo usaremos a menudo. Esto ya lo hemos hecho otras veces, no hace falta más que añadir una línea mágica al archivo de configuración:

(global-set-key (kbd "C-x g") 'magit-status)

Si no empezamos desde un repo existente, podemos iniciar uno con M-x magit-init o clonarlo con M-x magit-clone, que nos pedirá un nombre y una URL.

La ventanita de estado nos lista todos los archivos del repo, categorizados como Unstaged, Staged y Modified. Podemos movernos por la ventanita y decirle a Magit que haga el seguimiento a archivos o a trocitos de archivos, que haga un commit o que envíe los cambios a un repositorio remoto solo dando a una tecla.

Posicionándonos sobre el nombre de un archivo sin seguimiento o uno modificado y pulsando s (stage) lo añadiremos a los archivos a vigilar. Si nos posicionamos en el título y le damos a la s, añadiremos todos los de la sección. También podemos ignorar archivos con u (unstage).

Cuando estemos satisfechos de los añadido, le damos a la c para que se abran las opciones del commit y le vamos siguiendo el juego: pulsamos c para un commit normal, escribimos el mensaje y hacemos C-c C-c para decirle que hemos acabado. Antes os decía que las ventanitas tenían dos partes, la de las opciones y la de los comandos, los comandos se eligen dándole a la tecla correspondiente y las opciones superiores se activan posicionándose en la línea y pulsando RET, son los flags con los que Magit llamará al comando de git en cuestión.

Una de las cosas que más me gusta de Magit es que la información de las ventanitas se divide en secciones que se comportan como las de mi adorado Org y, por lo tanto, se expanden una vez con TAB y del todo con C-TAB.

Ver diferencias: diff

La ventanita de estado ya nos muestra los cambios al expandir el archivo con TAB, pero si queremos hacer más cosas tenemos la ventanita de los diffs, que contra todo pronóstico abrimos con d cuando estamos en la ventana de estado.

La ventanita de los diff

Sobre las ramas: branch, stash, checkout y merge

Las ramas en sí se tratan en la ventanita de las ramas que se abre con b y gestiona la creación y la destrucción de ramas así como saltar de una a otra con checkout.

Las fusiones de ramas, en cambio se tratan en la ventanita de merge que se abre con m y los stash en otra ventanita específica a la que llamamos con la z.

Manejar remotos: configuración, push y pull

El tema de los remotos tiene su miga por los términos que se utilizan. Yo como de git sé bastante poco, voy a contar el par de cosas que uso yo y os dejo unos enlaces para que leáis el manual.

Los remotos se gestionan con la ventanita que aparece al darle a la M, ahí se puede añadir un remoto, quitarlo o cambiarle el nombre. Cuando ya lo tengamos configurado, podemos hacer fetch o pull con f y F respectivamente, cada cual con su ventana de opciones correspondiente. Luego con P abrimos la ventanita de hacer push y mandamos los cambios a la rama remota que nos parezca.

En Windows, como suele ser habitual, el tema de pushear funciona distinto. Si estáis en ese caso el manual es vuestro amigo.

Otras cosicas

Un tema interesante para no malgastar recursos es desactivar VC, el modo de Emacs para el control de versiones. Nos dicen en la docu que para ello añadamos esta línea al archivo de configuración:

(setq vc-handled-backends nil)

Conclusión

Así como resumen os diré que me ha gustado Magit, es sencillo e intuitivo y a pesar de que me encante usar git desde la terminal y liarla petarda porque no me acuerdo de los comandos, usaré Magit siempre que edite cosas bajo control de versiones en Emacs.

¡Recordad! Para usar Magit solo hace falta abrir la ventanita de estado (M-x magit-status) y luego darle a teclas diversas. No nos exige además mucha memoria, solo con acordarnos de que la h nos abre la ventanita de ventanitas es suficiente. ¡Ah! Salir de las ventanitas es tan fácil como darle a la q.

Ya me contaréis qué tal.

La ventanita de ayuda

Referencias

El manual de Magit

Getting started in Magit

FAQ de Magit

Sonando:

Como ya os he dicho más veces uso Emacs de una manera un tanto curiosa, con su GUI y hasta con el ratón porque al final me muevo en un entorno gráfico y me encaja mejor así con el resto de herramientas (sí, uso cosas que no son Emacs). Parece ser que yo no soy la única, ya que hay modos de Emacs que añaden funcionalidades molonas al ratón y entre ellos mi favorito es org-mouse.el, que como su nombre indica se usa en mi amado modo Org.

Sirve para lo siguiente:

• Nos muestra un menú contextual al hacer click derecho en diferentes elementos
• Permite abrir y cerrar árboles con un click izquierdo
• Marca casillas de las listas de tareas al hacer click izquierdo sobre ellas

Parece poca cosa pero hacen de Emacs un lugar más amigable para los novatillos, los desmemoriados o los vagos, tres categorías a las que pertenezco.

Para activarlo solo hace falta añadir una línea al archivo de configuración:

;; Cargar org-mouse
(require 'org-mouse)

Podéis ver este modo en acción en este screencast¹:

Referencias

How to setup org-mouse to intuitively toggle checkboxes on org-mode? en StackExchange

5.6 Checkboxes en el manual de Org

Os dejo con una canción que he localizado por casualidad:

Casi es más largo el título que la definición o solución del problema.

Por mostrar un caso real explicaré el problema que tenia. Uso el paquete Projectile, que sirve para gestionar proyectos en emacs, recomiendo fuertemente que le echéis un ojo. Cuando se han abierto unos cuantos proyectos puede usarse la función projectile-switch-project, que permite cambiar el proyecto. El tema es que muchos directorios de mi home son en realidad enlaces simbólicos a otros sistemas de ficheros. Esto hace que los proyectos se me muestren con las rutas reales, no las rutas de los enlaces simbólicos. Por ejemplo, un proyecto en /home/drymer/Documentos/Ansible/roles/upgrade-all se me muestra como /media/.secret/Casa/Documentos/Ansible/roles/upgrade-all, lo cual es horroroso.

Lo que yo necesito es hacer que los proyectos en /media/.secret/Casa/ se muestren como /home/drymer/. Investigando, vi que lo que me hacia falta era usar una función de asesoramiento. No tengo claro si se traduce así, en inglés son Advising Functions. El tema es que estas funciones permiten, entre otras cosas, modificar la salida de una función elisp sin tener que redefinirla.

Por lo tanto, hay que averiguar que función es la que hay que modificar. En este caso, la función que da el nombre a los proyectos es projectile-project-root. Ahora crearemos una función simple que ejecute un replace-regexp-in-string en la salida:

(defun daemons/projectile-project-root (arg)
(replace-regexp-in-string "\\(/media/.secret/Casa\\)" (getenv "HOME") arg))

Un ejemplo de la ejecución de esta función:

(daemons/projectile-project-root "/media/.secret/Casa/Proyectos/nikola.el")

Solo nos queda añadir el filtro:

(advice-add 'projectile-project-root :filter-return #'daemons/projectile-project-root-filter)

Desgranemos el código:

• advice-add: Añade función de asesoramiento.
• projectile-project-root: La función que modificaremos.
• filter-return: De que modo modificamos la función.
• daemons/projectile-project-root-filter: Función con la que modificaremos el comportamiento de la primera.

La parte más interesante es la de filter-return, ya que este no es el único parámetro que se puede definir. Si quisiésemos, podríamos sustituir la función entera de muchas formas distintas. De hecho, si quisiésemos redefinir una función ya definida en alguna parte, las buenas prácticas dicen que hay que usar las funciones de asesoramiento. Recomiendo leer su sección del manual.

Este es un paquete al que cuesta cogerle el punto. Pisa un poco las funcionalidades de las macros, es un poco especialito y hay que tener un poco de imaginación al usarlo, pero una vez le pillas el truco es muy útil.

El paquete que muestra el siguiente gif es de multiple-cursors, y hace exactamente esto, abrir múltiples cursores en emacs. Lo he estado usando últimamente que he tenido que he estado usando Terraform en el trabajo, y se presta al uso de este paquete. Veamos un ejemplo:

La primera función es mc/mark-next-like-this, que crea un cursor en el siguiente elemento que es igual al que se está seleccionando. Tiene su equivalente mc/mark-previous-like-this para lo mismo pero para atrás. La siguiente función es mc/mark-next-lines que marca la siguiente linea sin más. Igual que la anterior, tiene su equivalente inverso, mc/mark-previous-lines. Y por último, el más útil, como todos los dwim, Do What I Mean. Se comporta de forma distinta según desde dónde se ejecute. Si se selecciona una región, introduces una cadena de carácteres y inserta cursores en esas regiones. En otra región hará otra cosa.

En la fabulosa página de Emacs Rocks hay un screencast sobre este paquete. Son solo tres minutos y muestra otro ejemplo de como usar este modo.