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 ,

He hablado de como crear tus archivos Org Mode mediante Emacs, pero… ¿Realmente vale la pena invertir tiempo en aprender los atajos de teclado y el funcionamiento de Emacs?.
Por supuesto que Sí!!! Y es que Emacs no solo funciona con Org Mode, sino que con cualquier sintaxis o cosa que se os ocurra.
Hoy vamos a utilizar Emacs como editor de Markdown. Voy a dividir el post en 2 partes, resaltado de sintaxis y previsulización del documento que estamos editando con refresco instantáneo.

Resaltado de Sintaxis

Para que Emacs resalte la sintaxis de Markdown, necesitamos instalar un paquete que encontraremos en Melpa, markdown-mode.

Instalación:

M-x package-install RET markdown-mode RET

Previsualización del documento

Para previsualizar el documento, instalaremos el paquete también de Melpa, Flymd.

Instalación:

M-x package-install RET flymd RET

Ahora si queremos previsualizar el documento, solo tenemos que introducir en Emacs:

M-x flymd-flyit

Esto, nos lanzará un archivo temporal y abrirá nuestro navegador web, para previsualizar el documento.

Por defecto se refresca en tiempo real y que podemos deshabilitar

Publicado por Angel

Cuando 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 ,

Soy de la opinión que el mejor modo de utilizar Org Mode es mediante Emacs. Aun así, para aquellos que se resisten inicialmente y conocen los atajos de teclado de Vim, os muestro paso a paso como Instalar el Plugin.
Tomo de Ejemplo este Plugin, pero si veis cualquier otro que os guste, siguiendo los mismos pasos, también podréis instalarlo.

Configurar Plugins

• Creamos la carpeta para alojar Vundle y clonamos el repositorio de GitHub:

Creamos la carpeta bundle, donde irán las carpetas de los plugins:

mkdir ~/.vim/bundle

Clonamos el repositorio de GitHub, en la ruta que especificamos a continuación:

git clone https://github.com/VundleVim/Vundle.vim.git ~/.vim/bundle/Vundle.vim

• Añadimos las siguientes líneas en el archivo de configuración de Vim (.vimrc): Los comentarios van con comillas delante “

vim ~/.vimrc

Pegamos este contenido:

set nocompatible              " be iMproved, required
filetype off                  " required

" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" alternatively, pass a path where Vundle should install plugins
"call vundle#begin('~/some/path/here')

" let Vundle manage Vundle, required
Plugin 'VundleVim/Vundle.vim'

" The following are examples of different formats supported.
" Keep Plugin commands between vundle#begin/end.
" plugin on GitHub repo
" Plugin 'tpope/vim-fugitive'
" plugin from https://vim-scripts.org/vim/scripts.html
" Plugin 'L9'
" Git plugin not hosted on GitHub
" Plugin 'git://git.wincent.com/command-t.git'
" git repos on your local machine (i.e. when working on your own plugin)
" Plugin 'file:///home/gmarik/path/to/plugin'
" The sparkup vim script is in a subdirectory of this repo called vim.
" Pass the path to set the runtimepath properly.
" Plugin 'rstacruz/sparkup', {'rtp': 'vim/'}
" Avoid a name conflict with L9
" Plugin 'user/L9', {'name': 'newL9'}

" All of your Plugins must be added before the following line
call vundle#end()            " required
filetype plugin indent on    " required
" To ignore plugin indent changes, instead use:
"filetype plugin on
"
" Brief help
" :PluginList       - lists configured plugins
" :PluginInstall    - installs plugins; append `!` to update or just :PluginUpdate
" :PluginSearch foo - searches for foo; append `!` to refresh local cache
" :PluginClean      - confirms removal of unused plugins; append `!` to auto-approve removal
"
" see :h vundle for more details or wiki for FAQ
" Put your non-Plugin stuff after this line

Instalar Plugins con Vundle

Para instalar el módulo con Vundle, añadimos la ruta del Plugin, en este caso la ruta de GitHub, al archivo .vimrc, después de Plugin ‘VundleVim/Vundle.vim’.

• Copiamos Plugin ‘jceb/vim-orgmode’, en el archivo de configuración de Vim .vimrc despues de Plugin ‘VundleVim/Vundle.vim’

    Plugin 'VundleVim/Vundle.vim'
    Plugin 'jceb/vim-orgmode'

• Instalamos el Plugins o Plugins, si hubiéramos añadido mas de uno, con el siguiente comando

vim +PluginInstall

Nota: También lo podríamos hacer entrando en Vim y escribiendo :PluginInstall

• Veremos como se abre Vim y comenzaran a descargarse el Plugin o Plugins que hayamos añadido en el archivo de configuración.

Nota: Podemos consultar donde esta el módulo, introduciendo en Vim :h vundle.

Desinstalar Plugins

Para desinstalar los Plugins y eliminar las carpetas de los mismos:

• Borramos del archivo .vimrc los Plugins a desinstalar
• Ejecutamos el siguiente comando, que a diferencia del anterior en el ejemplo de instalación, podriamos añadir +qall, que significa que una vez ejecutado, saldrá de Vim

vim +PluginClean +qall

Listar los Plugins Instalados

Entramos a Vim y ejecutamos :PluginList

Espero que os haya gustado. A disfrutar con el Org Mode y Vim. Y si te gusta mucho, utiliza también Emacs. :P

Publicado por Angel

Cuando Canal en Telegram

Grupo en Telegram

uGeekPodcast en Twitter

YouTube

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

Tags: , blog , emacs , orgmode , vim , vundle ,

Emacs parece complicado, pero nada de eso. En el podcast de hoy os muestro unos pequeños consejos de iniciación a Emacs.

Todas las Notas y Enlaces de este podcast en: https://ugeek.github.io/iniciandonos-a-emacs-y-orgmode/

Suscribiros al Podcast del Atareao.es Feed -> https://www.atareao.es/mp3-feed

Escuchar el Podcast de MosqueterWeb con mi buen amigo Carlos Castillo:
http://www.ivoox.com/lunes-mosqueteroweb-016-carlos-castillo-audios-mp3_rf_28827738_1.html

Suscribete a sus Podscast:

• Historacing -> http://feeds.feedburner.com/Historacing
• ReflexPodcast -> http://feeds.feedburner.com/ReflexPodcast

https://ugeek.github.io/

Suscribete al Podcast : RSS , ITunes , ivoox

Suscribete a uGeekRadio : Feed

Publicado por Angel

Canal en Telegram

Grupo en Telegram

uGeekPodcast en Twitter

YouTube

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

Tags: , emacs , podcast ,

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 y en tar

“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.

Hará un mes mas o menos que no reviso los feeds que sigo sobre emacs y creo que ya va siendo hora, y de paso había pensado en compartir aquellos que me resulten interesantes, tal y como hace Sacha Chua en su blog, pero no como algo recurrente, si no como algo puntual ya que justamente ahora tengo mas de 130 posts relacionados con emacs pendientes de leer, incluso es posible que de para mas de un post.

No tengo intención de leerlos todos a fondo, son mas que nada una lista de post que quiero revisar a fondo, así que es posible que se me cuele alguno poco interesante.

Vamos allá.

Enlaces sobre Emacs para revisar en profundidad:

• Blogging with Emacs Org | ZCL.SPACE

Seguro que me viene muy bien, contando con que son las dos tecnologías que uso para escribir este blog.

• Emacs: Convert Image Files in Dired

Convertir y procesar imágenes en dired. Por curiosidad del código elisp.

• A Ramble About ELisp | Nathan Hughes' blog

Un breve post sobre la motivación de alguien para aprender emacs lisp.

• GitHub - valignatev/heaven-and-hell: Emacs light/dark theme toggler

Una función para alternar fácilmente entre un tema claro y otro oscuro

• Marcin Borkowski: 2018-04-15 counsel-org-clock

No se muy bien que es, según dice el post es un org-clock con esteroides, debería probarlo y de paso revisar algunos enlaces que vienen dentro del post sobre hydra

• Emacs: Keyboard Macro

Como usar las macros de teclado, acompañado de un gráfico muy divertido sobre los geeks y las tareas repetitivas

• Emacsair! A walk through the Magit interface

Un paseo por la interfaz de Magit. Tiene muy buena pinta, debería leerlo en profundidad, es una herramienta que uso mucho a diario.

• Working with dired – Alex's Adventures on the Infobahn

Quiero echarle un ojo al elisp que viene, que parece para abrir un frame con dired desde consola y parece interesante.

• Using Emacs Episode 47 - Magit | C'est la Z

Un vídeo sobre Magit de la serie Using Emacs. Si no conocéis estos vídeos os los recomiendo, se aprende mucho de ellos.

• Use Imenu to list comments in current buffer | Chen's blog

Listando los comentarios del buffer con Imenu. Quiero revisar el código, que tengo muchas ganas de aprender a usar imenu.

• GitHub - emacs-helm/helm-system-packages: A Helm interface to the package man...

Gestionando los paquetes del SO con helm desde emacs. Se merece un try para ver como funciona.

• Serve files over HTTP directly from Emacs : emacs

Servir ficheros HTML directamente desde Emacs. Curiosidad.

• What minor modes do you always use? : emacs

¿Qué modos menores usas siempre?. Estas preguntas son muy interesantes para ver que responde la gente y conocer nuevos modos.

• GitHub - sebastiencs/company-box at 93effecb9eeaedbe954a271610479e7c3da29564

Añade iconos a company. No creo que lo use, pero puede ser interesante

Bueno, una vez que he anotado las cosas que creo que pueden ser interesantes creo que lo suyo es que las revise en profundidad antes de ponerme a mirar otras cosas, y si puedo compartir algo de lo que aprenda pues mucho mejor.

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:

Esto mas que un post va a ser un breve apunte de algo que vi por casualidad el otro día, y se trata de como poner emacs con fondo transparente.

No se trata de una funcionalidad que me interese ni que esté pensando en utilizar, pero quería dejar el apunte por si le puede interesar a alguien o incluso a mi yo del futuro.

Para conseguir este efecto deberemos modificar el valor del parámetro alpha del frame de la siguiente forma:

   (set-frame-parameter (selected-frame) 'alpha '(92 . 90))
   (add-to-list 'default-frame-alist '(alpha . (92 . 90)))
   

Alpha

Según podemos ver en la documentación, este parámetro especifica la opacidad que queremos darle al frame. Debe ser un número entero del 0 al 100, donde 0 es completamente transparente y 100 completamente opaco. Si ponemos un nil le decimos a Emaca que no se modifique la opacidad del frame, dejándolo al gestor de ventanas.

Para prevenir que el frame desaparezca y no podamos editar existe una variable frame-alpha-lower-limit que define la mínima opacidad que puede tener el frame. Por defecto es 20.

Ojo, en la documentación avisan de que el parámetro está semi-obsoleto. A parte de que puede no funcionar correctamente en todos los sistemas operativos ni en todas las versiones de Emacs.

Fuentes

• Font and Color Parameters - GNU Emacs Lisp Reference Manual
• EmacsWiki: Transparent Emacs
• Beautifying Emacs! - Muto&aposs Blog

aqui una serie de pequeños trucos y apaños recientes

primero, sin buscarlo intencionalmente he estado utilizando emacs en modo consola, en un terminal grafico, pasado por ssh y filtrado bajo gnu screen.

Acostumbrado a la version grafica de emacs y al no tener interferencia en practicamente ninguna combinacion de teclas. Al toparme de lleno primero con la interferencia del terminal y luego la de screen, me descoloque bastante, pero ya empiezo a acostumbrarme e ingresar algunos comandos por su nombre y asignar rutas alternativas a algunos comandos, ademas de explorar modos que por lo general no uso extensivamente, como por ejemplo *eshell* donde descubro estupefacto que de vez en cuando company-mode (autocompletado) interfiere ingresando espacios al azar y/o borrando caracteres… ja, ja, ja, la solucion a este mal es desactivar company en ese modo en especifico

(setq company-global-modes '(not eshell-mode))

el segundo truco suculento esta relacionado con el lenguaje de marcas imaginaria morg al que ni en un futuro cercano, medio (y tal vez lejano) creo contar con la habilidad de programarle un modo propio, asi que sigo ultrajando a org-mode y sus facilidades. Una caracteristica que hechaba mucho en falta es el resaltado de la sintaxis “en linea” de comandos “arroba” asi que cada vez que visitaba un texto, lo unico que se me ocurria era resaltar dicha sintaxis mediante el comando highlight-regexp con una regexp esoterica.

Recientemente le agregue un gancho al emacs para que lance una serie de highlights que automaticen el resaltado. No es perfecto, ya que aveces se resaltan cosas aleatoriamente y otras la regexp es incapas de encajar con la sintaxis, pero de momento sirve de apaño

;; cargar ficheros .morg en modo org
(add-to-list 'auto-mode-alist '("\\.morg\\'" . org-mode))

;; resaltar "cosas"
(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)
            )
          )

y finalmente, la primer funcion en emacs lisp (shell-region-insert-for-markdow) que programo “por ver si funcionaba”. Un poco de corta y pega, un algo de lo traducido del manual de introduccion a emacs lisp y un tanto de prueba y herror (con h)

(defun shell-region (start end)
  "execute region in an inferior shell"
  (interactive "r")
  (shell-command  (buffer-substring-no-properties start end)))

(defun shell-region-insert-for-markdown (start end)
  "execute region in an inferior shell and insert output with markdown sintax"
  (interactive "r")
  (save-excursion
    (goto-char end)
    (insert "\n")
    (dolist (line
             (split-string
              (shell-command-to-string (buffer-substring-no-properties start end))
              "[\n]")
             t)
      (insert "\n" "    " line))
    )
  )

(global-set-key (kbd "C-c x") 'shell-region)
(global-set-key (kbd "C-c i") 'shell-region-insert-for-markdown)

la primer funcion ejecuta la region activa en una shell mostrando la salida en un buffer (si la hay). La segunda funcion hace lo mismo pero agrega el salto mortal de insertar la salida del comando dentro del mismo buffer con el formato de (cuatro espacios al inicio de) markdown. Je, je, a que mola!

por supuesto con las respectivas combinaciones de teclado para parecer aun mas pro. En cuanto a (e)lisp en si, pues esta curioso, sigo creyendo que ajustar todo a listas es un bonito truco academico pero incomodo en el uso diario. No contar con tipado aun si las funciones tienen nombres (medio) claros poco ayuda y desconocer que demonios devuelve una funcion hasta leerse la documentacion a detalle tampoco es motivante, acaso seguimos en los 70’s?

Aun asi curioso, estimulante y esoterico programar para emacs es, de a poco le estoy encontrando el gusto…

este par de comandos los hice un poco pensando en xiki aquella shell montada en emacs con una ambicion desmedida que cerro su codigo una vez (creo) y luego termino en naahhh. Hubiera sido un buen modo, seeh hubiera sido un buen modo… mmm, no parece muy dificil de implementar, no lo habra hecho ya algien (de buen corazon y espiritu GPL hippie)?

actualizacion: si existe un modo que imita a xiki, no muy logrado pero se puede usar y se llama elxiki. Gracias a la gente de r/emacs!.

luego de cargar el modo

$ git clone https://github.com/lahorichargha/elxiki
(add-to-list 'load-path "ruta-a-directorio-elxiki")
(require 'elxiki)

para enterarse de como usarlo visitar ruta-a-directorio-elxiki/menu/elxiki.menu y ejecutar M-x elxiki-mode

happy hacking!

fuentes

• https://stackoverflow.com/questions/6286579/emacs-shell-mode-how-to-send-region-to-shell
• https://emacs.stackexchange.com/questions/21042/disable-minor-mode-in-major-mode

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.

Ando últimamente bastante liadilla y agradezco cualquier herramienta que me facilite la vida. Una que me hace muy feliz es el modo menor de Emacs CDLaTeX, que acabo de descubrir y se ha convertido en imprescindible en mi día a día. En concreto lo uso en combinación con el modo Org, que trae su propia variante org-cdlatex. Paso a hablaros sobre ello.

El modo CDLaTeX

Tal y como dice en su README, CDLaTeX es un modo menor para la inserción rápida de entornos y movidas matemáticas en LaTeX:

CDLaTeX is a minor mode for Emacs supporting fast insertion of environment templates and math stuff in LaTeX

Lo escribió el mismo señor que el modo Org, Carsten Dominik, y se puede encontrar tanto en MELPA como en Github. Requiere texmathp.el que dicen que es parte de Emacs a partir de la versión 21.3, pero yo tuve que instalar AucTeX (que también lo contiene) para hacerlo funcionar.

Ecuaciones rápidas

La idea de este modo es evitarnos el tedio de escribir desde cero las ecuaciones de LaTeX y los símbolos matemáticos. Es muy listo y sabe cuándo estamos dentro de un bloque matemático (entre \begin{equation} y \end{equation}) y cuándo no, y así activa y desactiva funcionalidades según el contexto. Por ejemplo, al escribir un guión bajo nos añade automáticamente las llaves para que escribamos dentro el subíndice.

La tecla principal de este modo es el TAB, que hace de todo:

• Predice comandos: si lo pulsamos después de haber escrito una parte de un comando nos lo completa. Me encanta porque equ + TAB inserta directamente un entorno de ecuaciones, ¡así de fácil! Podemos ver todas abreviaturas con M-x cdlatex-command-help.

• Reduce subíndices y superíndices simples: nos escribe automáticamente las llaves para los subíndices y superíndices pero podemos eliminarlas para los casos de una sola letra pulsando el TAB delante de la llave de cierre.

• Mueve el cursor a la siguiente unidad de interés: podemos avanzar por las ecuaciones con el TAB alegremente.

No solo del TAB se vive, también tenemos otras funcionalidades chulas:

• Entornos rápidos C-c { nos mete entornos como align dentro del bloque de ecuaciones.

• El apóstrofe modifica el carácter anterior, añadiendo un punto encima u otras movidas locas matemáticas. Si lo pulsamos y esperamos un poco nos aparece un cuadro con todas las opciones disponibles.

• El acento grave introduce comandos, por ejemplo `a escribe \alpha tanto dentro como fuera del entorno matemático, `b escribe \beta y así sucesivamente. Varios acentos cambian de nivel, tomando el caso de la letra l como ejemplo, precedida de un acento escribe \lambda, con dos acentos \ell, y con tres \log. Lo que es utilísimo para los que escribirmos mucha mate. ¡Un truco! Para escribir letras griegas mayúsculas, tras introducir una con el acento grave y la letra, podemos usar M-b para movernos al inicio de la palabra y M-c para que Emacs nos la ponga en mayúsculas. Es fantástico. Al igual que el apóstrofe, si esperamos un poco después de pulsarlos nos aparece un cuadro con las opciones.

Lo único que me queda por contaros es que si este modo os conquista como a mí, podéis activarlo siempre con Org añadiendo esta línea al archivo de configuración:

;; Activar CDLaTeX con Org mode
(add-hook 'org-mode-hook 'turn-on-org-cdlatex)

¡Y hala! ¡Productividad a tope!

¿Vosotras qué modos y herramientas usáis para simplificar vuestro trabajo? Ilustradme, porfis.

Referencias

org-cdlatex en el manual de Org

CDLaTeX en GitHub

Últimamente estoy dejando salir a mi celta interior:

Estoy fusionando mi amor por Emacs con mi objetivo de ser más productiva (¡todavía más!) al trabajar. Esto pasa evidentemente por perder menos tiempo, que se traduce a su vez en tres cosas:

• Usar lo menos posible el ratón, con la ventaja añadida de que mis pobres muñecas sufren mucho menos.

• Salir lo menos posible de Emacs, si Emacs puede hacer todo ¿por qué abandonarlo? Esto conlleva afinar la configuración, algo que considero una inversión a largo plazo (y me divierte lo suyo, además).

• Automatizar tareas repetitivas, reducir el tiempo gastado en repetir lo mismo una y otra vez es generar tiempo para otras cosas. También se reduce el número de veces que pulso una combinación de teclas determinada y, por lo tanto, mis manitas están más felices.

Un tema interesante que encaja en las tres categorías anteriores es tener preparado un entorno de trabajo al abrir Emacs la primera vez del día. ¿Cómo hago esto? Con una lista de tareas escrita en org que se abre automáticamente al iniciar Emacs. Como curro en diferentes historietas, en esta lista describo lo que tengo que hacer y enlazo los archivos en los que estoy trabajando. De esta manera, me sirve un poco como acta del trabajo que voy realizando y me permite tener localizados los documentos de los diferentes proyectos en los que ando.

Además, basta configurar con qué programa debe abrirse qué tipo de archivo para que tengamos ya la herramienta correcta dispuesta para que le demos caña, cuando no podemos usar directamente Emacs, claro.

Para que la lista de tareas nos aparezca al abrir Emacs solo hay que añadir una línea al final de nuestro archivo de configuración:

(find-file "RUTA_A_LA_LISTA")

He llegado a este sistema de pura casualidad, pero la verdad es que se adapta muy bien a mis necesidades. Otro día os hablaré más en detalle sobre cómo uso Org y compartiré con vosotros mi configuración completa para este modo.

Tengo curiosidad, ¿cómo os organizáis vosotros? ¡Contadme, contadme!

Referencias

A Baby Steps Guide to Managing Your Tasks with Org

Suena mientras escribo esto:

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.

Últimamente he estado toqueteando bastante Ansible. Para quien no lo conozca, Ansible es un gestor de configuraciones. Permite instalar y configurar programas y configuraciones en un ordenador o en 1.000. Por eso se usa en el ámbito de la Integración Continua. Pero bueno, ya hablaré más en profundidad de ello en otro articulo.

Por ahora hablaré de lo que uso para editar playbooks. Uso yaml-mode, ansible-doc y ansible-vale-mode. Por suerte los playbooks de Ansible se escriben en el maravilloso formato Yaml, muy cómodo para editarlo. El modo no ofrece mucho más que la identación y los colores, pero tampoco hace falta mucho más:

(use-package yaml-mode
:ensure t)

ansible-doc lo que hace es ofrecer el comando de línea ansible-doc pero desde emacs, con helm o ivy si se usa alguno. La primera linea de la sección config enlaza el ansible-doc-mode al yaml-mode, por lo que cuando se edite yaml, solo hay que ejecutar C-? y se accederá a los docs. Por defecto la primera vez que se lo llama tarda bastante en responder, por que guarda la respuesta para que las siguientes veces sea más rápido. Yo lo que he hecho es añadir la segunda línea, que hace que este cacheo se produzca al iniciar emacs. Tarda más en arrancar emacs, pero dado que solo lo arranco una vez cada muchas semanas, no me resulta un problema.

(use-package ansible-doc
  :ensure t
  :config
  (add-hook 'yaml-mode-hook #'ansible-doc-mode))

Y por último, ansible-vault. Este paquete es otro wrapper de su equivalente de terminal. Para quién no lo sepa, vault es la forma de gestionar variables sensibles en ansible. Se puede usar de dos formas, con una contraseña genérica o una por proyecto. Para lo primero, solo hay que crear un fichero ~/.vault_pass. Para lo segundo, hay que hacer uso del fichero .dir-locals.el. Este fichero permite concretar variables por directorio, como su nombre indica. Es algo propio de emacs, no de ansible-vault. Por lo tanto, en ese fichero habría que poner algo como esto:

((yaml-mode
(ansible-vault-pass-file . "~/.ansible-vault/custom_vault_pass")))

(use-package ansible-vault
  :ensure t
  :config
  (defun ansible-vault-mode-maybe ()
    (when (ansible-vault--is-vault-file)
      (ansible-vault-mode 1)))
  (add-hook 'yaml-mode-hook 'ansible-vault-mode-maybe))

Con esto, se hace mucho más fácil y cómodo editar playbooks de Ansible. Y si además queremos visitar la página de la documentación oficial, siempre se puede usar counsel-dash.

En el articulo sobre la programación literaria para sysadmins se pudo ver que los bloques de babel en org-mode son muy útiles. Lo malo que tiene ejecutar estos bloques es que se bloquea emacs. El dichoso tema de la concurrencia de nueva. Pero como siempre, se puede trampear.

Se puede abrir un proceso paralelo de emacs para que ejecute el bloque sin que bloquee el proceso de emacs principal. Me estaba pegando con ello justo cuando descubrí que alguien ya lo habia hecho mejor. Veamos un ejemplo. Primero un ejemplo síncrono, que no tiene mucho sentido pero es gratis:

Muy fácil de usar, como se puede ver. Lo único malo que tiene es que no se puede usar la variable :session, por lo tanto se pierde la idempotencia. Se puede usar :noweb, pero cada bloque ejecutará todo lo anterior, lógicamente. Pero bueno, no me suele afectar demasiado para lo que uso. Para instalar el paquete que habilita este parámetro hay que añadir esto al archivo de configuración de emacs:

(add-to-list 'el-get-sources '(:name ob-async
                                    :type github
                                    :pkgname "astahlman/ob-async"))

(if (not (el-get-package-installed-p 'ob-async))
(el-get 'sync 'ob-async))

(use-package ob-async
:load-path "el-get/ob-async/")

Una vez instalado y configurado, se puede usar como cualquier otro parámetro de bloque. Se puede establecer en el propio bloque, como se puede ver en el segundo gif, o se puede establecer como una propiedad en un árbol.