Onda Hostil: Lo que he aprendido: el ratón y org 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 screencast1:

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:

-1:-- Lo que he aprendido: el ratón y org mode (Post Ondiz)--L0--C0--February 19, 2018 06:00 PM

MGallego: Codificando y Decodificando Urls con Emacs

Últimamente estoy teniendo que hacer muchas pruebas en las que pasar urls codificadas (urlencoded) dentro de una url, mi flujo de trabajo consistía en sacar el listado de urls que tenía que pasar como parámetro y una a una ir convirtiéndolas a través de una aplicación web para formar la url completa y testearlo.

A parte de ser un flujo bastante malo, tanto las urls como los parámetros los edito dentro del emacs, así que obviamente si el paso que tengo que realizar en un servicio externo lo puedo realizar también dentro pues puedo aprovechar todas las ventajas que me da el editor.

Estuve buscando un poco a ver si ya existían funciones nativas de emacs para realizar esta tarea, o quizá en algún modo que ya tuviese instalado y pudiese usar, pero no encontré nada, hasta que llegué a esta web.

Aquí encontré un par de funciones que puedo copiar en mi configuración de emacs para poder usarlas y que me han resultado muy útiles.

Por un lado tenemos una que realiza una codificación de tipo urlencode al texto seleccionado

  (defun url-encode-region (start end)
    "Replace a region with the same contents, only URL encoded."
    (interactive "r")
    (let ((text (url-hexify-string (buffer-substring start end))))
      (delete-region start end)
      (insert text)))

y por otro tenemos la inversa, decodifica el texto seleccionado.

  (defun url-decode-region (start end)
    "Replace a region with the same contents, only URL decoded."
    (interactive "r")
    (let ((text (url-unhex-string (buffer-substring start end))))
      (delete-region start end)
      (insert text)))

Las he probado y funcionan correctamente, así que las he añadido a mi configuración de emacs para poder usarlas cuando quiera con M-x url-encode-region y M-x url-decode-region respectivamente.

Esto y unas cuantas macros es lo único que necesito para crear todas las urls de prueba que necesito y así ahorrarme mucho tiempo.

-1:-- Codificando y Decodificando Urls con Emacs (Post )--L0--C0--February 14, 2018 06:54 PM

MGallego: Instalación del Modo Slack de Emacs

Actualmente en la empresa en la que trabajo, y en varias anteriores, estamos usando slack como herramienta de comunicación. Como me gusta trastear con emacs e intentar integrar todo he estado buscando como instalar el modo slack pero no me ha quedado claro.

En la web oficial a parte de explicar bastante bien como conseguir el token me ha parecido demasiado escaso el resto sobre la instalación, así que he decidido documentar como lo he acabado instalando.

Instalando el paquete

La mejor forma de instalar un paquete actualmente en emacs es a través de use-package. Si aún no lo estás utilizando te recomiendo que lo reviséis.

     (use-package slack
       :ensure t)
   

Con esto simplemente instalamos el paquete, podría poner toda la configuración junta como en la documentación original, pero es justo el motivo por el que me resultaba confuso, así que lo mejor será ir paso a paso

Obteniendo el token

Para obtener el token tenemos dos formas, la sencilla y la complicada, he probado las dos, y me he quedado con la sencilla, ya que para la complicada tenemos que crear nuestra propia app de slack y si no tenemos permisos de administrador del equipo o si como en mi caso ya estamos usando 10 apps, el limite de uso gratuito, pues no vamos a poder usarlo. Para la forma dificil lo mejor es seguir los pasos de la documentación del paquete.

La forma sencilla es la siguiente:

  • Abrimos el cliente web de slack, y accedemos a nuestro equipo (team):

  • Abrimos el inspector del navegador que estemos usando. Botón derecho sobre la web e inspeccionar elemento.

  • Dentro buscamos "xoxs", donde encontraremos el token que necesitamos. Lo copiamos.

Esto es lo único que necesitamos. Llevo poco usándolo y no se si ese token se regenera con el tiempo, yo lo hice por primera vez hace un par de días y me sigue funcionando, si caduca pues o bien lo hacemos por el método difícil o cuando caduque buscamos el token actualizado de la misma manera.

Probando el token

Ahora que tenemos el token, antes de meternos en la conexión a través de configuración, lo mejor es probar la conexión a través de comandos.

Ejecutamos M-x slack-start Esto nos irá pidiendo los datos de conexión.

Aquí es donde no queda nada claro en la documentación oficial que datos deberemos meter, ya que si hemos utilizado la forma sencilla de sacar un token no tenemos ni client ni secret.

Esto son los datos que debemos introducir:

Team Name: Nombre del equipo, en mi caso Devops Chat. Da lo mismo si no es exacto, por dentro lo sacará del token.

Client Id: Lo dejamos en blanco, pulsamos enter

Client Secret: Lo dejamos en blanco, pulsamos enter

Token: Aquí es donde debemos meter el token que hemos sacado del navegador.

Si todo ha ido bien ya tendremos una conexión completa donde podremos probar el modo, ojo esto no la almacenará en ningún sitio, tenemos que registrar el equipo en la configuración de nuestro emacs, para cuando lo abramos e iniciemos slack sepa a que equipos conectarse.

Configuración completa

Esta sería una configuración completa, con use-package, donde ya se registra un equipo y unos canales a los que queremos conectarnos.

     (use-package slack
       :commands (slack-start)
       :init
       (setq slack-prefer-current-team t)
       :config
       (slack-register-team
        :name "DevOps Chat"
        :default t
        :client-id ""
        :client-secret ""
        :token "xoxs-aaaaaaaaaa-bbbbbbbbbbbb-cccccccccccc-dddddddd"
        :subscribed-channels '(aws ideas nix docker)
        :full-and-display-names t
        ))
   

Como podéis ver el token que he pegado no es real, debéis reemplazarlo con el vuestro, este token está asociado a vuestro usuario así que no lo hagáis público, ya que con ese token cualquier persona podría publicar en vuestro nombre.

BUG TimeOut

REQUEST [error] Callback is not called when stopping process! Explicitly calling from timer.

Casualmente cuando estaba escribiendo los ejemplos de este post me topé con un bug en el modo.

Solo he usado el equipo de DevOps Chat porque es un grupo público donde poder coger capturas, pero en el día a día uso el slack de mi empresa.

En el slack del trabajo hay pocos usuarios y no me ha dado ningún problema, pero al sacar el listado de conversaciones del ejemplo me da un error del tipo REQUEST [error] Callback is not called when stopping process! Explicitly calling from timer..

Creo que esto es debido a la cantidad de mensajes y usuarios que hay en ese equipo, he probado a cambiar el timeout a un número mucho mayor, por defecto son 5 segundos y parece que funciona.

   (setq slack-request-timeout 240)
   

En mi caso me ha valido con 240, en tu caso quizá no te haga falta tanto tiempo, o incluso setear nada.

Os dejo el enlace al bug en github por si necesitais mas información.

Comprobando la instalación

Para comprobar lo mas sencillo es comenzar una conversación con el bot de slack, para ello realizaremos los siguientes pasos:

  • Actualizamos el listado de conversaciones directas M-x slack-im-list-update. Nos pedirá el team, podemos usar el tabulador para seleccionarlo (es en este paso cuando puede dar el error del que he hablado antes).

  • Seleccionamos el chat M-x slack-im-select Igual que en el caso anterior con el tabulador veremos la lista de posibles salas.

  • Saludamos con un "hello", a ver si el bot nos responde.

Finalizando

No quiero entrar en mas detalles porque como he comentado antes solo llevo un par de días utilizando y me queda mucho por probar aún y experimentar, lo que vaya aprendiendo lo iré publicando por el blog, mientras tanto podéis continuar con la documentación oficial.

Y como siempre cualquier duda o corrección del post, puedes dejarme un comentario.

-1:-- Instalación del Modo Slack de Emacs (Post )--L0--C0--February 09, 2018 10:37 PM

Bad Daemons: Modificar la salida de una función de emacs lisp sin redefinirla

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.

-1:-- Modificar la salida de una función de emacs lisp sin redefinirla (Post drymer)--L0--C0--February 05, 2018 07:30 AM

Bad Daemons: Expandir región por unidades semánticas

Ahí va otro paquete chorra de emacs que me hace la vida más fácil. expand-region, como dice el título, expande la región en unidades semánticas. Pero a que me refiero con una unidad semántica?

Pues a una parte imaginaria en la que partimos el código. Se ve especialmente claro en elisp:

(use-package rainbow-delimiters
  :ensure t
  :config
  (add-to-list 'auto-mode-alist '("\\.el\\'" . rainbow-delimiters-mode)))

Las unidades semánticas que podemos sacar son:

  • delimiters
  • rainbow-delimiters-mode
  • "\\.el\\'" . rainbow-delimiters-mode
  • ("\\.el\\'" . rainbow-delimiters-mode)
  • '("\\.el\\'" . rainbow-delimiters-mode)
  • add-to-list 'auto-mode-alist '("\\.el\\'" . rainbow-delimiters-mode)
  • (add-to-list 'auto-mode-alist '("\\.el\\'" . rainbow-delimiters-mode))
  • use-package rainbow-delimiters :ensure t :config (add-to-list 'auto-mode-alist '("\\.el\\'" . rainbow-delimiters-mode))
  • (use-package rainbow-delimiters :ensure t :config (add-to-list 'auto-mode-alist '("\\.el\\'" . rainbow-delimiters-mode)))

Como una imágen vale más más que mil palabras, ahí va un gif, que suman unos cuantos millones:

expand-region.gif

También podéis ver el screencast de Magnars, el autor de Emacs Rocks y el propio expand-region.

-1:-- Expandir región por unidades semánticas (Post drymer)--L0--C0--January 29, 2018 07:30 AM

Onda Hostil: Lo que he aprendido: ecuaciones rápidas con CDLaTeX

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:

-1:-- Lo que he aprendido: ecuaciones rápidas con CDLaTeX (Post Ondiz)--L0--C0--January 13, 2018 06:30 PM

Quijote Libre: Paquetes Emacs: try, wich-keys y org-bullets.

Cómo dijé en mi anterior entrada vuelvo a retomar el tema Emacs, en que ando enfrascado, con esta entrada en que os presento diferentes paquetes que he descubierto, de entre los cientos que hay para ampliar sus posibilidades, y mi replanteamiento del fichero de configuración. Os cuento … Reaprendiendo Emacs. Aunque la revisión que estoy […]
-1:-- Paquetes Emacs: try, wich-keys y org-bullets. (Post Quijote Libre)--L0--C0--January 11, 2018 07:45 PM

uGeek: Kanban para Org Mode

Publicado por Angel

Kanban para Org Mode


10 Meses utilizando Org Mode + Emacs y cada vez va a ser mas difícil el dejar este método para gestionar mis tareas y tomar notas.

Hace unos 2 meses, gestionando mi listas de tareas en mi Org Mode, eché de menos el poder implementar el método Kanban y poder ver mis tareas de una forma más gráfica.

Tuve el comentario en un grupo reducido de Telegram, donde esta Daniel Primo, que compartió conmigo esta joya que ha encontrado.

asciicast

Christian Köstlin, inspirado en el artículo Emacs, org-mode, Kanban, Pomodoro… Oh my…, creo un paquete que no esta disponible en ningún repositorio pero que podemos instalar de modo manual, para obtener un Panel dinámico Kanban, dentro de nuestro Org Mode. Lo mejor de todo, es que no sólo podremos ver estas tareas gráficamente, sino que también cambiar el estado de las mismas.

Instalación

Instalaremos previamente dash, una librería avanzada para trabajar con tablas, si no la tenemos instalada

M-x package-install RET dash RET

Recuerda que M-x=(Alt+x) y RET=Intro

Descargaremos el archivo con la terminal

wget https://raw.githubusercontent.com/ugeek/emacs-config/master/org-kanban.el

También podemos hacerlo desde el Explorador web
org-kanban.el

Cargamos en Emacs el org-kanban.el que hemos descargado

M-x load-file RET ruta_del_archivo RET

Gestión en nuestro Org Mode

Nuestro archivo .org, debe tener en la cabecera del documento, los estados de las tareas. Yo he decidido añadir más estados y personalizarlo en Castellano

#+TODO: PENDIENTE(t) | SIGuIENTE(s) | PROCESO(p) | ESPERA(e) | REALIZADO(d)

A diferencia del ejemplo de Christian Köstlin, sitúo mi panel Kanban al inicio, seguido de mis tareas, pudiendo ver el resumen del estado de estas de un modo más rápido.

Para generar el Panel Kanban, escribiremos este código:

#+BEGIN: kanban                                                                                                                           
#+END:                                                                                                                                    

Situando el cursor sobre #+BEGIN: kanban pulsamos C-c C-c y nos generará de forma automática el panel kanban

Ahora situándonos sobre una tarea en el panel, podremos cambiar su estado:

Estado Siguiente

M-x org-kanban/next

Estado Anterior

M-x org-kanban/prev

Estado Siguiente o Anterior

M-x org-kanban/shift

Por defecto cambiará al estado siguiente, pero pulsando las teclas j o k, podremos cambiar al estado que deseemos.

  • j = Anterior
  • k = Siguiente

También sobre la tarea en el panel, si tecleamos C-c C-o, nos llevará hasta donde está la entrada de esta tarea y ver si está compuesta de subtareas.

Nota: Recordar que el panel es estático, así que si cambiamos el estado de la taréa fuera del panel, deberemos actualizarlo desde el panel con (C-c C-c).

No se que opináis vosotros, pero para mi esto es alucinante. Tener todo en un único archivo de texto en Modo Org, de tan poco tamaño.

Repositorio original org-kanban de Christian Köstlin


Canal en Telegram

Grupo en Telegram

uGeekPodcast en Twitter

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

Tags: , blog , emacs , kanban , orgmode ,

<noscript>Please enable JavaScript to view the <a href="https://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>
-1:-- Kanban para Org Mode (Post )--L0--C0--January 07, 2018 09:00 PM

Onda Hostil: Mi entorno de trabajo en Emacs

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:

-1:-- Mi entorno de trabajo en Emacs (Post Ondiz)--L0--C0--January 03, 2018 03:28 PM

Quijote Libre: La serie de Mike Zamansky sobre Emacs.

No hace mucho que descubrí a Mike Zamansky  y  sus videos y aunque sólo sea por lo ordenado, limpio y claro de sus explicaciones,  a  pesar de que no soy muy dado al Inglés, me parece una serie digna de recomendar y tener como referencia básica, sobre todo si sois programadores. En cualquier caso para […]
-1:-- La serie de Mike Zamansky sobre Emacs. (Post Quijote Libre)--L0--C0--December 29, 2017 09:56 AM

Onda Hostil: Lo que he aprendido: imágenes inline en Org

¡Hola, gentes! ¡He aprendido nuevas cosas de Org!

Resulta que si hemos instalado Emacs con soporte para imágenes, podemos decirle a Org mode que nos las muestre dentro de nuestro documento. Esto es maravilloso porque implica que no es necesario que exportemos a HTML o pdf para tener un documento legible sino que desde dentro del propio Org podemos editar y ver directamente todo. Veamos cómo.

Mostrar las imágenes

Como ya sabemos, se pueden insertar imágenes en Org con la siguiente línea:

[[file:RUTA_A_IMAGEN]]

Tenemos unas funciones, que invocamos con M-x seguido de su correspondiente nombre, que nos permiten decidir si Org nos muestra la imagen a la que hacemos referencia en lugar de la línea esa que tan bien conocemos:

  • org-display-inline-images: muestra las imágenes
  • org-redisplay-inline-images: vuelve a cargar las imágenes
  • org-toggle-inline-images (C-c C-x C-v): si las estaba mostrando las deja de mostrar y viceversa
  • org-remove-inline-images: deja de mostrar las imágenes

El lugar de usar estas funciones todo el rato, también se puede establecer el comportamiento para determinado documento mediante una variable de inicio:

#+STARTUP: inlineimages

Mostrará las imágenes que hemos enlazado. En cambio:

#+STARTUP:noinlineimages

No las mostrará. Para que nos recargue el documento y hagan efecto los cambios en estas variables es útil la combinación C-x C-v (buscar archivo alternativo), una de mis favoritas.

Redimensionar las imágenes

Lo que nos puede pasar ahora es que la imagen nos quede gigantesca o diminuta porque Org nos la inserta en su tamaño original. Nos falta, por tanto, redimensionarla para que de verdad sea útil.

Para ello primero tenemos que darle el valor nil a la variable org-image-actual-width, que es la que controla el tamaño de las imágenes y que por defecto vale t, es decir, que las imágenes sean siempre del tamaño original. Con el valor de nil busca primero en los atributos si le hemos dado nosotros un tamaño y, si no, la muestra del tamaño original.

Yo he decidido cambiar el valor de esta variable en el archivo de configuración, pero puede hacerse también mediante una variable local:

;; Redimensionar si hay atributo, si no dejar tamaño original
(setq org-image-actual-width nil)

Ahora controlamos el tamaño con los atributos de imagen, unas líneas similares a las que dan inicio al documento que se ponen delante de la imagen y que sirven para establecer el tamaño, el pie de imagen y otras cosas. Por ejemplo, si vamos a exportar a LaTeX establecemos las opciones de cada imagen con el atributo ATTR_LATEX:

#+ATTR_LATEX: :width 0.5\textwidth
[[file:RUTA_A_IMAGEN]]

O para cambiar el tamaño de la imagen que se muestra dentro de Emacs:

#+ATTR_ORG: :width 300
[[file:RUTA_A_IMAGEN]]

Creo que para esto último hace falta Imagemagick, en Linux me va fetén pero en Windows no hay manera de hacerlo carrular.

Mostrar imágenes generadas mediante código

Si estamos creando las imágenes dentro de un bloque de código (con Ditaa, por ejemplo), igual nos interesa que después de fabricar la imagen la muestre. Para ello podemos añadir un hook al archivo de configuración que ejecute org-display-inline-images tras activar el bloque:

;; Mostrar imágenes tras ejecutar bloque de código
(add-hook 'org-babel-after-execute-hook 'org-display-inline-images 'append)

De esta manera, en lugar de crearnos solamente un enlace a la figura en la línea de resultados nos la pintará dentro de Emacs y podremos ver si está a nuestro gusto.

inline

¡Esto es todo por hoy, hermanas! Pronto más Org y más Emacs.

Referencias

4.4 Handling links en el manual de Org

12.7.5 LaTeX specific attributes en el manual de Org

15.6 Summary of in-buffer settings en el manual de Org

Emacs org-display-inline-images en StackOverflow

How to resize images in org-mode en StackOverflow

Org mode C-c C-c to display inline image en StackExchange

Scale inline images in orgmode

Image display size in Org


-1:-- Lo que he aprendido: imágenes inline en Org (Post Ondiz)--L0--C0--December 26, 2017 05:32 PM

MGallego: Deshabilitando las teclas del cursor en Emacs

Una de las cosas que me gustaría aprender de emacs es a usar sus propias teclas de movimiento, esto es: C-p C-n C-b y C-f pero la verdad me cuesta mucho, sobre todo porque no se mecanografia y porque estoy acostumbrado a moverme con las teclas del cursor. Así que he decicdido hacer dos cosas, aprender a mecanografiar y desactivar las teclas del cursor en al menos uno de los ordenadores en los que trabajo.

Como puede llegar a ser muy frustrante el no poder usar las teclas del cursor he decidido no cambiar el comportamiento en la configuración por defecto, si no que he creado una función para desactivarlas en el momento en el que me apetezca.

La función es la siguiente:

  (defun disable-arrow-keys ()
    "Disable the arrow keys"
    (interactive)
    (global-unset-key (kbd "<left>"))
    (global-unset-key (kbd "<right>"))
    (global-unset-key (kbd "<up>"))
    (global-unset-key (kbd "<down>"))
    (global-unset-key (kbd "<C-left>"))
    (global-unset-key (kbd "<C-right>"))
    (global-unset-key (kbd "<C-up>"))
    (global-unset-key (kbd "<C-down>"))
    (global-unset-key (kbd "<M-left>"))
    (global-unset-key (kbd "<M-right>"))
    (global-unset-key (kbd "<M-up>"))
    (global-unset-key (kbd "<M-down>"))
    )
-1:-- Deshabilitando las teclas del cursor en Emacs (Post )--L0--C0--December 22, 2017 11:46 PM

Onda Hostil: Lo que he aprendido: abrir archivos con un programa externo en Org

¡Ay el modo Org! ¡Cómo me encanta! Cada día le encuentro más funcionalidades, creo que llegará un momento en el que solo usaré este modo para todas mis actividades, me da un poco de miedito.

Acabo de descubrir que podemos decirle a Org que nos abra los archivos que enlazamos en un documento con la aplicación que nos parezca. Esto me ha parecido megaútil para referenciar en mi lista de tareas qué he hecho y dónde está. Así, puedo escribir las conclusiones que he sacado de determinado tema y enlazar el script de Matlab en el que lo investigo o el paper donde he leído el método.

Esta configuración de con qué programa se abre qué tipo de archivo está guardada en la variable org-file-apps, que podemos describir con:

C-h v org-file-apps

o bien:

M-x describe-variable org-file-apps

Nos dice lo siguiente:

org-file-apps is a variable defined in ‘org.el’.
Its value is ((auto-mode . emacs)
(“\.mm\'” . default)
(“\.x?html?\'” . default)
(“\.pdf\'” . default))

External applications for opening ‘file:path’ items in a document. Org-mode uses system defaults for different file types, but you can use this variable to set the application for a given file extension. The entries in this list are cons cells where the car identifies files and the cdr the corresponding command.

Vemos ahí que la variable org-mode-apps es una lista en la que cada elemento tiene la forma (tipo_archivo . programa)1. Los tipos de archivo que están en auto-mode los abrirá con Emacs usando el modo correspondiente; para los que pone default llamará al programa que tengamos definido en nuestro sistema operativo para ese tipo de archivo. En vez de default podemos darle también una orden concreta, claro.

Lo que tenemos que hacer por lo tanto es añadir a esa lista el tipo de archivo y el programa con el que queremos que lo abra. En mi caso quiero que me abra los .m y .fig, scripts e imágenes de Matlab respectivamente, con el programa por defecto de mi sistema, es decir, Matlab. Para ello he modificado el archivo de configuración de la siguiente manera:

;; Abrir archivos de Matlab fuera de Emacs
(add-hook 'org-mode-hook
           '(lambda ()
          (add-to-list 'org-file-apps
               '("\\.m\\'" . default)
               '("\\.fig\\'" . default)
               )))

Para los que prefiráis las combinaciones de teclas, podéis decidir cómo abrir el archivo enlazado cambiando la secuencia de teclas con la que accedéis al enlace:

  • C-c C-o (open) abrirá lo enlazado según nuestra configuración
  • C-u C-c C-o abrirá el archivo en Emacs
  • C-u C-u C-c C-o dejará al sistema decidir en qué programa abre el archivo

Pues hasta aquí por hoy, sigo con mi proceso de centralizar todo en Org.

Referencias

Emacs org-mode file/viewer associations en StackOverflow

org-file-apps settings? en la lista de correo de Org

Relative path link to .xls file from org-mode en StackExchange

What does the dot in the following emacs command mean? en StackOverflow


Sonando en mi cabeza:


  1. Técnicamente es (regexp . función), pero nos entendemos. El punto ese que hay en medio quiere decir que es un dotted pair, algo que podré explicar cuando aprenda algo de Lisp. 
-1:-- Lo que he aprendido: abrir archivos con un programa externo en Org (Post Ondiz)--L0--C0--December 20, 2017 09:30 AM

Bad Daemons: Múltiples cursores en emacs

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:

multiple-cursors.gif

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.

-1:-- Múltiples cursores en emacs (Post drymer)--L0--C0--December 11, 2017 07:30 AM

Maxxcan's Site: Mitos sobre GNU Emacs

Pre-Introducción Este artículo posiblemente es con el que debería haber empezado la serie de post…
-1:-- Mitos sobre GNU Emacs (Post admin)--L0--C0--December 07, 2017 05:34 PM

Maxxcan's Site: Como configurar Emacs

Introducción Como ya debemos saber Emacs es más que un editor por lo que algo…
-1:-- Como configurar Emacs (Post admin)--L0--C0--December 03, 2017 06:37 PM

Quijote Libre: Video introducción a GNU Emacs de Derek Banas

Gracias al gran sitio que es  Irreal, una de las mejores fuentes de información sobre Emacs que conozco, he podido ver este video de Derek Banas (@NewThinkTank). Probablemente sea un poco escaso para usuarios con experiencia, pero es indudable que es una buena aproximación a nuestro querido Emac y por eso la dejo aqui. No […]
-1:-- Video introducción a GNU Emacs de Derek Banas (Post Quijote Libre)--L0--C0--November 21, 2017 11:00 AM

Quijote Libre: GTD con org-mode: Planteamiento inicial

Vamos a ver si empezamos, si es que este bajón otoñal me deja, y lo primero de todo pediros disculpas por el nuevo cambio de la plantilla, pero no me estaba gustando nada el funcionamiento de los títulos en la nueva y hasta que no me maneje mejor para tocarle las tripas a WordPress creo […]
-1:-- GTD con org-mode: Planteamiento inicial (Post Quijote Libre)--L0--C0--November 01, 2017 06:18 PM

Maxxcan's Site: Qué es spacemacs

la web de spacemacs
1 Introducción Mi idea era seguir haciendo artículos básicos sobre Emacs, pero viendo que ya…
-1:-- Qué es spacemacs (Post admin)--L0--C0--October 17, 2017 03:52 PM

nba - GNU's Rock: Emacs, configuracion de verano

todo empezo una tarde calida cuando cambie de distro a manjaro, abri el emacs para ponerme a programar “el morg” (que esta en go) y aparecia un mensaje de error muuu largo, informando que el flycheck (un modo para verificar el codigo mientras se va escribiendo) no localizaba la ruta al ejecutable del flycheck-go. Como no encontraba el origen del problema y queria tunear el emacs, me propuse abandonar el sistema que tenia para agregar extensiones al emacs, el cual consistia basicamente en buscar un paquete, clonar el repositorio del codigo y probar hasta se cargara a lo bestia sin tirar del sistema de paquetes del que dispone emacs… je, como decir que no me gustan las cosas automagicas que hacen las cosas sin que me entere, pero bueno, siendo emacs me dare el lujo de ser un poco mas permisivo

asi pues la nueva configuracion, es de esas sencillitas en las que colocas el paquete que quieres instalar/usar en una orden y luego al abrir emacs se descarga, instala y puede que hasta configure los paquetes que hagan falta, asi a la brava y sin tener ni idea de como

por lo tanto si quieres replicar mi configuracion

por ejemplo para programar en go, c, tener un lector de rss, o iniciar en emacs con el tema nascii, primero instala emacs, y luego crea una carpeta en tu home con

wget https://nasciiboy.github.io/data/init-dot-el.zip
unzip init-dot-el.zip -d ~/.emacs.d
rm init-dot-el.zip
emacs

el comprimido con forma de zip, almacena dos ficheros: init.el, que es donde se coloca toda configuracion de emacs y pondre a continuacion casi tal cual y nascii-theme.el mi tema de colores personal, baraje el subirlo a melpa para que tambien forme parte de la instalacion magica, pero me da peresa y creo que el tema visual es cosa de cada quien, unque desde luego mi tema es el unico que es correcto y valido…

las extenciones para programar en go requieren que instales las siguientes herramientas

go get -u github.com/nsf/gocode
go get -u github.com/rogpeppe/godef
go get -u golang.org/x/tools/cmd/goimports
go get -u github.com/jstemmer/gotags

por lo demas, solo haria falta substituir todos los /home/nasciiboy por tus rutas correspondientes

init.el

;;; nascii-config: --- another day in Emacs
;; Substituir /home/nasciiboy (y otras rutas) segun corresponda.

;; el thema nascii
(load-file "~/.emacs.d/nascii-theme.el")

;; fullscreen
(toggle-frame-fullscreen)

;; desactivar barra de (menu|herramientas|desplazamiento)
(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)

;; tamaño de la fuente
(set-face-attribute 'default nil :height 140)

;; inhibir mensajes y pantalla de inicio
(setq inhibit-startup-buffer-menu t)
(setq inhibit-startup-screen t)
(setq inhibit-startup-message t)
(setq inhibit-startup-echo-area-message "usuario")

;; mensaje en el buffer scratch
(setq initial-scratch-message "

  ;;     _____ __  __    _    ____ ____
  ;;    | ____|  \\/  |  / \\  / ___/ ___|
  ;;    |  _| | |\\/| | / _ \\| |   \\___ \\
  ;;    | |___| |  | |/ ___ \\ |___ ___) |
  ;;    |_____|_|  |_/_/   \\_\\____|____/


  ;;      ____   ___  _  ______    _
  ;;     |  _ \\ / _ \\| |/ / ___|  | |
  ;;     | |_) | | | | ' /\\___ \\  | |
  ;;     |  _ <| |_| | . \\ ___) | |_|
  ;;     |_| \\_\\\\___/|_|\\_\\____/  (_)

")

;; hora en formato 24 horas:
(setq display-time-day t display-time-24hr-format t)
(display-time)

;; reemplazar "yes" por "y" en el prompt
(fset 'yes-or-no-p 'y-or-n-p)

;; habilitar narrow & wide
(put 'narrow-to-region 'disabled nil)

;; habilitar upcase-region y downcase-region
(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)

;; resaltar apertura y cierre de paréntesis
(setq show-paren-delay 0
      show-paren-style 'parenthesis)
(show-paren-mode)

;; visualizar lineas sin truncar ⏎
(set-default 'truncate-lines t)

;; Al borrar cosas moverlas a la papelera.
;; el directorio corresponde a la papelera en gnome3
(setq delete-by-moving-to-trash t
      trash-directory "~/.local/share/Trash/files")

;; al escribir en modo texto cortar lineas automaticamente
(add-hook 'text-mode-hook 'turn-on-auto-fill)
;; longitud de lineas
(setq-default fill-column 80)

;; Core settings
;; UTF-8 please
(set-charset-priority 'unicode)
(setq locale-coding-system   'utf-8)   ; pretty
(set-terminal-coding-system  'utf-8)   ; pretty
(set-keyboard-coding-system  'utf-8)   ; pretty
(set-selection-coding-system 'utf-8)   ; please
(prefer-coding-system        'utf-8)   ; with sugar on top
(setq default-process-coding-system '(utf-8-unix . utf-8-unix))

;; (setq make-backup-files nil) ; detener creacion de ficheros respaldo~ (descomentar)
(setq auto-save-default nil)    ; detener creacion de ficheros #autoguardado#
;; colocar todos los ficheros de respaldo en el directorio ~/.emacs.d/backups/
(setq backup-directory-alist `(("." . ,(concat user-emacs-directory "backups"))))

;; espacios en lugar de tabulaciones
(setq-default indent-tabs-mode nil)

;; eliminar espacios en blanco
(add-hook 'before-save-hook 'delete-trailing-whitespace)

;; c++-mode para headers y ficheros C
(add-to-list 'auto-mode-alist '("\\.h$" . c++-mode))
(add-to-list 'auto-mode-alist '("\\.c$" . c++-mode))

;; xml-mode para ficheros xml
(add-to-list 'auto-mode-alist '("\\.xml$" . sgml-mode))

;; dar permisos de ejecución a scripts luego de guardar
(setq after-save-hook
      (quote (executable-make-buffer-file-executable-if-script-p)))

;; historial de ficheros abiertos
(require 'recentf)
(recentf-mode t)
(setq recentf-max-saved-items 200)
(global-set-key (kbd "C-c o") 'recentf-open-files)

;; atajos
;; Wind Move <> movimiento entre ventanas
(global-set-key [s-left]  'windmove-left)
(global-set-key [s-right] 'windmove-right)
(global-set-key [s-up]    'windmove-up)
(global-set-key [s-down]  'windmove-down)
;; atajos para emacs cli
(global-set-key (kbd "C-c <left>")  'windmove-left)
(global-set-key (kbd "C-c <right>") 'windmove-right)
(global-set-key (kbd "C-c <up>")    'windmove-up)
(global-set-key (kbd "C-c <down>")  'windmove-down)

;; parrafos
(global-set-key (kbd "C-.") 'forward-paragraph)
(global-set-key (kbd "C-,") 'backward-paragraph)
(global-set-key (kbd "C-q") 'fill-paragraph)
(global-set-key (kbd "C-;") 'delete-indentation)

;; ibuffer en lugar de list-buffers
(global-set-key (kbd "C-x C-b") 'ibuffer)

(global-set-key [f12] 'eval-buffer) ;; evaluar buffer (elips) actual
(global-set-key [f9] 'compile)      ;; compilar buffer (por ejemplo en C)
(global-set-key [f7] 'eww)          ;; abrir una direccion con eww

;; atajos de eww el navegador incorporado de emacs
(global-set-key (kbd "C-x w o") 'eww)
(global-set-key (kbd "C-x w b") 'eww-add-bookmark)
(global-set-key (kbd "C-x w l") 'eww-list-bookmarks)
(global-set-key (kbd "C-x w f") 'eww-open-file)

;; esto esta muuuuy chulo, cuando abres eshell te permite ejecutar los
;; comandos en la lista como si estubieras dentro de un terminal "real"
(setq eshell-visual-commands '("htop" "vi" "vim" "mocp" "top" "less" "more" "elinks" "elinks" "git" "sr" "surfraw"))

;; en direct coloca el tamaño de los ficheros con formato para humanos
(setq dired-listing-switches "-alh")

;; interpretes
(setq scheme-program-name "racket")        ; instalar previamente racket
(setq inferior-lisp-program "clisp")       ; instalar previamente clisp
(setq python-shell-interpreter "python3")  ; instalar previamente python3

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                    ;;
;;         ""#                    "                   ;;
;;  mmmm     #    m   m   mmmm  mmm    m mm    mmm    ;;
;;  #" "#    #    #   #  #" "#    #    #"  #  #   "   ;;
;;  #   #    #    #   #  #   #    #    #   #   """m   ;;
;;  ##m#"    "mm  "mm"#  "#m"#  mm#mm  #   #  "mmm"   ;;
;;  #                     m  #                        ;;
;;  "                      ""                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; con esta seccion te permite instalar las extenciones automagicamente
(require 'package)
(add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/") t)
(package-initialize)

(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(require 'use-package)
(setq use-package-always-ensure t)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: company-mode         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package company)
(add-hook 'after-init-hook 'global-company-mode)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: flycheck             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package flycheck)
(flycheck-mode t)
(add-hook 'python-mode-hook 'flycheck-mode)
(add-hook 'emacs-lisp-mode-hook 'flycheck-mode)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: magit-mode           ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package magit)

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: markdown-mode        ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package markdown-mode)
(add-to-list 'auto-mode-alist '("\\.text\\'" . markdown-mode))
(add-to-list 'auto-mode-alist '("\\.markdown\\'" . markdown-mode))
(add-to-list 'auto-mode-alist '("\\.md\\'" . markdown-mode))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: go-mode              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; go get -u github.com/nsf/gocode
;; go get -u github.com/rogpeppe/godef
;; go get -u golang.org/x/tools/cmd/goimports
;; go get -u github.com/jstemmer/gotags

(setenv "GOPATH" "/home/nasciiboy/go")
(setenv "PATH" (concat (getenv "PATH") ":" "/home/nasciiboy/go/bin"))
(setq exec-path (append exec-path (list (expand-file-name "/home/nasciiboy/go/bin") (expand-file-name "/home/nasciiboy/.go/bin"))))
;; con la `list` de arriba  =======^^^^
;; solucione el problema de agregar
;; nuevos paths donde emacs buscara los ejecutables de go


(use-package go-mode)
(use-package go-gopath)
(use-package company-go)
(use-package go-stacktracer)
(use-package go-add-tags)
(use-package go-eldoc)
(use-package go-direx)
(use-package flymake-go)

(add-to-list 'company-backends 'company-go)
(add-hook 'go-mode-hook (lambda ()
                          (setq indent-tabs-mode nil)
                          (setq tab-width 2)))
(add-hook 'go-mode-hook 'go-eldoc-setup)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: haskell-mode         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package haskell-mode)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: rust-mode            ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package rust-mode)
(add-hook 'rust-mode-hook (lambda ()
                            (setq rust-indent-offset 2)
                            (setq rust-format-on-save nil)))

(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-mode))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: lua-mode             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package lua-mode)
(add-to-list 'interpreter-mode-alist '("lua" . lua-mode))
(setq lua-indent-level 2)

(use-package love-minor-mode)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: fish-mode            ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package fish-mode)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: multiple-cursors     ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package multiple-cursors)

(global-set-key (kbd "C->") 'mc/mark-next-like-this)
(global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
(global-set-key (kbd "s-c C->") 'mc/mark-all-like-this)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: lorem-ipsum          ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package lorem-ipsum)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: elfeed               ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package elfeed)
(setq elfeed-feeds
      '(
        "http://blog.chuidiang.com/feed/"
        "http://blog.desdelinux.net/feed/"
        "http://blogubuntu.com/feed"
        "http://carlini.es/feed/"
        "http://cucarachasracing.blogspot.com/feeds/posts/default?alt=rss"
        "http://ea4bns.blogspot.com/feeds/posts/default"
        "http://elarmarioinformatico.blogspot.com/feeds/posts/default"
        "http://elblogdeliher.com/feed/"
        "http://enavas.blogspot.com/feeds/posts/default?alt=rss"
        "http://es.xkcd.com/rss/"
        "http://feeds.feedburner.com/blogspot/bytelearning"
        "http://feeds.feedburner.com/btroot?format=xml"
        "http://feeds.feedburner.com/diegocg?format=xml"
        "http://feeds.feedburner.com/Esbuntucom?format=xml"
        "http://feeds.feedburner.com/GabuntuBlog"
        "http://feeds.feedburner.com/Gambas2MisProgramas?format=xml"
        "http://feeds.feedburner.com/geeklandlinux"
        "http://feeds.feedburner.com/SYSADMIT?format=xml"
        "http://feeds.feedburner.com/teknoplof/muQI?format=xml"
        "http://feeds.feedburner.com/Ubunlog?format=xml"
        "http://feeds.feedburner.com/ugeek"
        "http://feeds.feedburner.com/ugeekblog"
        "http://feeds.feedburner.com/UnBrutoConDebian?format=xml"
        "http://feeds.weblogssl.com/genbetadev"
        "http://fernand0.github.io/feed.xml"
        "http://hackingthesystem4fun.blogspot.com/feeds/posts/default"
        "http://hispalinux.es/node/feed"
        "http://humanos.uci.cu/feed/"
        "http://lamiradadelreplicante.com/feed/"
        "http://linuxmanr4.com/feed/"
        "http://maslinux.es/feed/"
        "http://mhyst.es/blogs/index.php?tempskin=_rss2"
        "http://misnotaslinux.blogspot.com/feeds/posts/default"
        "http://nasciiboy.github.io/index.xml"
        "http://nosturi.es/feed/"
        "http://papermint-designs.com/roor/rss.xml"
        "http://parceladigital.com/feed/"
        "http://planet.emacsen.org/atom.xml"
        "http://quijotelibre.com/feed/"
        "http://radioela.org/spip.php?page=backend"
        "http://ranchoelectronico.org/feed/"
        "http://red-orbita.com/?feed=rss2"
        "http://rufianenlared.com/feed/"
        "http://softwarelibre.deusto.es/feed/"
        "http://www.blackhats.es/wordpress/?feed=rss2"
        "http://www.decrecimiento.info/feeds/posts/default"
        "http://www.dmdcosillas.org/feed/"
        "http://www.eldiario.es/rss/hojaderouter/"
        "http://www.hackplayers.com/feeds/posts/default?alt=rss"
        "http://www.jgimenez.info/feed/"
        "http://www.kdeblog.com/feed/"
        "http://www.lapipaplena.net/feed/"
        "http://www.linuxadictos.com/feed"
        "http://www.linuxhispano.net/feed/"
        "http://www.maxxcan.com/feed/"
        "http://www.muylinux.com/feed/"
        "http://www.portallinux.es/feed"
        "http://www.radioela.org/spip.php?page=backend-auteur&id_auteur=115"
        "http://www.rafaelrojas.net/feed/"
        "http://www.rootzilopochtli.com/feed/"
        "http://www.tomatesasesinos.com/feed/"
        "http://www.tomatuordenador.net/feed/"
        "http://www.ubuntizando.com/feed/"

        "https://andalinux.wordpress.com/feed/"
        "https://aprendizdesysadmin.com/feed/"
        "https://asm86.wordpress.com/feed/"
        "https://autodefensainformatica.radioalmaina.org/feed/"
        "https://birrasybits.wordpress.com/feed/"
        "https://blog.adrianistan.eu/feed/"
        "https://blog.gvsig.org/feed/"
        "https://cartaslinux.wordpress.com/feed/"
        "https://ciberlatino.wordpress.com/feed/"
        "https://codingornot.com/feed"
        "https://colaboratorio.net/feed/"
        "https://compilando.audio/index.php/feed/podcast/"
        "https://comunicatelibremente.wordpress.com/feed/"
        "https://daemons.cf/rss.xml"
        "https://diariodeunalinuxera.com/feed/"
        "https://duglasm.wordpress.com/feed/"
        "https://elbinario.net/feed/"
        "https://elblogdecarlosvelasco.wordpress.com/feed/"
        "https://eliasbrasa.wordpress.com/feed/"
        "https://eliotreyna.blogspot.com/feeds/posts/default"
        "https://elpinguinotolkiano.wordpress.com/feed/"
        "https://elzorrolibre.noblogs.org/feed/"
        "https://enekoamieva.com/blog/feed/"
        "https://feedpress.me/podcastlinux"
        "https://gutl.jovenclub.cu/feed/"
        "https://h4ckseed.wordpress.com/feed/"
        "https://infostatex.blogspot.com/feeds/posts/default"
        "https://jummp.wordpress.com/feed/"
        "https://jvare.com/feed/"
        "https://kernelpanicblog.wordpress.com/feed/"
        "https://laenredadera.net/feed/"
        "https://lapastillaroja.net/feed/"
        "https://lasindias.net/feed"
        "https://leninmhs.wordpress.com/feed/"
        "https://lignux.com/feed/"
        "https://linuxgnublog.org/es/feed"
        "https://mierda.tv/feed/"
        "https://miguelpinia.wordpress.com/feed/"
        "https://milagrosrp.wordpress.com/feed/"

        "https://mx.ivoox.com/es/podcast-podcast-el-precipicio_fg_f176717_1.xml"
        "https://mx.ivoox.com/es/podcast-podcast-kde-espana_fg_f1249423_1.xml"
        "https://mx.ivoox.com/es/reality-cracking_fg_f159955_filtro_1.xml"
        "https://www.ivoox.com/podcast-fran-casas_fg_f1449982_1.xml"
        "https://www.ivoox.com/podcast-podcast-verne-wells-ciencia-ficcion_fg_f1100419_1.xml"

        "https://neoranger.github.io/feed.xml"
        "https://noelonassis.wordpress.com/blog/feed/"
        "https://notxor.nueva-actitud.org/feed/all.rss.xml"
        "https://ondahostil.wordpress.com/feed/"
        "https://otroespacioblog.wordpress.com/feed/"
        "https://pfctelepathy.wordpress.com/feed/"
        "https://picodotdev.github.io/blog-bitix/index.xml"
        "https://poesiabinaria.net/feed/"
        "https://radioliberadaelpodcast.wordpress.com/feed/"
        "https://radioslibres.net/rss/"
        "https://thelinuxalchemist.wordpress.com/feed/"
        "https://victorhckinthefreeworld.com/feed/"
        "https://vidaembebida.wordpress.com/feed/"
        "https://www.atareao.es/blog/feed/"
        "https://www.cambiadeso.es/feed/"
        "https://www.linuxito.com/?format=feed&type=rss"
        "https://www.ochobitshacenunbyte.com/feed/"
        "https://xkcd.com/rss.xml"
        "https://xnet-x.net/blog/feed/"
        ))

(global-set-key [f6] 'elfeed)
(global-set-key [f5] 'elfeed-update)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                               ;;
;;   ___  ___ _ __(_)_ __ | |_   ;;
;;  / __|/ __| '__| | '_ \| __|  ;;
;;  \__ \ (__| |  | | |_) | |_   ;;
;;  |___/\___|_|  |_| .__/ \__|  ;;
;;                  |_|          ;;
;;                               ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Mostrar/ocultar archivos ocultos en direc
(defun dired-dotfiles-toggle ()
  "Mostrar/ocultar archivos ocultos"
  (interactive)
  (when (equal major-mode 'dired-mode)
    (if (or (not (boundp 'dired-dotfiles-show-p)) dired-dotfiles-show-p)
        (progn
          (set (make-local-variable 'dired-dotfiles-show-p) nil)
          (message "h")
          (dired-mark-files-regexp "^\\\.")
          (dired-do-kill-lines))
      (progn (revert-buffer)
             (set (make-local-variable 'dired-dotfiles-show-p) t)))))

(global-set-key (kbd "C-c h") 'dired-dotfiles-toggle)

(defun increment-number-at-point ()
  (interactive)
  (skip-chars-backward "0-9")
  (or (looking-at "[0-9]+")
      (error "No number at point"))
  (replace-match (number-to-string (1+ (string-to-number (match-string 0))))))

(defun decrement-number-at-point ()
  (interactive)
  (skip-chars-backward "0-9")
  (or (looking-at "[0-9]+")
      (error "No number at point"))
  (replace-match (number-to-string (- (string-to-number (match-string 0)) 1))))

(global-set-key (kbd "C-c +") 'increment-number-at-point)
(global-set-key (kbd "C-c -") 'decrement-number-at-point)

fuentes

https://github.com/melpa/melpa

https://github.com/abrochard/emacs-config/blob/master/configuration.org

https://www.reddit.com/r/emacs/comments/4fqu0a/automatically_install_packages_on_startup/

-1:-- Emacs, configuracion de verano (Post )--L0--C0--September 29, 2017 12:47 AM

nba - GNU's Rock: Run Scheme

En el anterior post (cronologico del blog) comente algunos interpretes de Scheme. Ya que en Emacs tenemos un interprete de elisp nativo, supuse que habria un metodo sencillo, para correr Scheme, pero, por que correr todo un interprete cuando se puede echar mano del interprete del sistema de turno y powerizarlo con el incomparable Emacs, o si, hasta Gulie que en terminal era insipido, se vuelve Sexi! Todos los interpretes adquieren historial, hasta los que no lo tenian!

… o eso es lo que aprendi en este post, que me limito a traducir y alterar parcialmente (pues supongo al estar en una wiki es permitido)

(nota: el post original, hablan de un modo “quack”, pero viendo que mensionan emacs-goodies, asumo que es algo “antiguo”, viniendo de ejecutar los interpretes en consola salvajemente, con lo que ofrece emacs por defecto tengo suficiente! (por ahora…))

Configuracion Basica

Coloque el codigo a continuacion en su fichero init.el, para configurar su uso con Scheme

;;; Siempre con resaltado de sintaxis
(global-font-lock-mode 1)

;;; tambien con resaltado de parentesis
(setq show-paren-delay 0
      show-paren-style 'parenthesis)
(show-paren-mode 1)

;;; Este es el nombre binario de mi implementacion de Scheme
(setq scheme-program-name "scm")

Asegurese de remplazar "scm" con el nombre de la implementacion de Scheme que este utilizando en su sistema

(resaltar que ya tenia activo show-parent-mode, la instruccion setq show-paren-delay 0 hace que no halla retraso al momento del resaltado, que por el uso que le daba, presuponia estaba asignado en 1 segundo… correccion segun C-h v show-parent-delay era de 0.125 segundos, maravilloso!)

Trabajando con Scheme

Cuando abre un archivo, los nombres de los archivos que terminan en .scm o .ss seran asumidos como archivos de Scheme, y se abriran con el modo scheme de Emacs, que proporciona resaltado de sitaxis e indentacion automatica cuando pulse TAB, y por spuesto resaltado de parentesis coincidentes.

Ejecutar Scheme en Emacs

Puede ejecutar un interprete de Scheme en Emacs. Esto le permite controlar el envio de los datos de entrada a su interprete desde emacs.

En primer lugar, crearemos una ventana para correr el proceso de Scheme presionando C-x 2, seguido por C-x o para ir a esta. Ahora podemos ejecutar un proceso de Scheme ingresando M-x run-scheme. Esto ejecutara el proceso que configuro anteriormente en su .init.el

Si esta realizando una prueba temporal, escriba en un buffer cualquiera (setq scheme-program-name "scm") (remplazar scm), coloque el cursor en el parentesis de cierre y pulse C-x C-e, de esta forma puede probar un interprete distinto, luego de cerrar la secion previa escribiendo (exit)

Para volver a la ventana inicial, presione C-x o.

Puede utilizar C-x C-e para enviar una expresion. Tambien puede enviar una region, un comando previo o incluso el buffer entero, para consultar el resto de atajos activos y disponibles (no vinculados con ninguna combinacion de teclado) presione C-h m

Comandos basicos

Algunos comandos basicos de movimiento del cursor:

  • C-a: Inicio de linea.
  • C-e: Fin de linea.
  • C-p: Linea previa.
  • C-n: Linea suguiente.
  • C-f: Avarzar un caracter.
  • C-b: Retroceder un caracter.
  • C-x delback: Matar hasta el inicio de linea
  • M-p: Retroceder por el historial.
  • M-n: Avanzar por el historial.
-1:-- Run Scheme (Post )--L0--C0--August 20, 2017 11:42 PM

nba - GNU's Rock: Por que GNU Emacs?

Si el tiempo antes de precindir de interfaces para interactuar con los computadores se extiende lo suficiente, Emacs, terminara por ser un sistema operativo autosuficiente

coloca una pista de sonido, relajate y disfruta de este post al estilo “lo que otros IDEs no quieren que sepas”, “la increible historia de emacs, no podras creer el final”, “Emacs el editor que no esperabas”, …

〜( ̄△ ̄〜) he, pero es que yo utilizo (vim|VS|atom|eclipse|nano|…) y no necesito un editor viejuno y raro!

(∿°○°)∿ tu-ru-ru-ru-ru-ru ohhh yeah! estoy mas cerca de un usuario basico, que uno intermedio de Emacs, no tengo duda alguna que lo que sea que hagas con tu editor actual lo podrias hacer con Emacs, que sea de forma sencilla, ya es otra cosa, mientras tanto, piensa en el como un estupendo complemento/substituto para varias herramientas, o un proyecto a largo o mediano plazo que estoy absolutamene seguro disfrutaras

la forma mas simple para explicar por que emacs, seria terminal vs aplicaciones graficas, para el segundo tienes un monton de interfaces distintas no diseñadas para colaborar entre si, para el primero solo hace falta un poco de aprendizaje antes de comenzar a concatenar acciones, que de otra forma serian extenuantes

Emacs, es un interprete, que hace muchas cosas, pero todas ellas con una “interfaz” comun, es decir, si sabes como moverte en un fichero de texto, sabes como moverte en alguna de sus varias “aplicaciones”, pues sus programadores tratan de lograr una coherencia global en cuanto al significados de los comandos que pueden aplicarse, y en caso de duda siempre tienes la documentacion a mano

「(゚ペ) bueno, entoces ocupas emacs para hacer de todo?

\_( ̄、 ̄ 彡  ̄ー ̄)_/ -☆・ ・ ・ ‥……━━●

no, pero no hay dia que encienda el pc sin abrir varias instancias de emacs, diria que paso el 80% del tiempo en emacs, con varias terminales

de ves en cuando aprendo un nuevo truco, mas, en Emacs, la distancia entre mis habilidades y el dominio total, es tan grande como lo es el mar

(。´>д<)っ彡 entoces que haces?

leer libros, maquetar libros, organizar/elimimar/navegar ficheros, programar, de ves en cuando navegar por la red, ver irc, revisar feeds, algo de git y poco mas.

me gustaria leer tambien el correo, pero no he encontrado un tutorial para vagos

que? cual es el punto de hacer eso con emacs?

(。´>д<)っ彡

  1. como mayor virtud, esta la interfas uniforme, no importa la rareza del lenguaje de programacion, si es un visor rss, o un navegador de archivos, los comandos principiales cumplen el mismo proposito, es decir no tengo que recordar comportamientos independientes para cada situacion, ni navegar por raros menus o botones graficos misteriosos

  2. la capacidad de configurar cualquier aspecto para que se adapte a mis necesidades y gustos no tiene comparacion, tanto si quiero o no menus, numeracion, tal o cual tipografia y color, puede configurarse de forma independiente o global segun nuestra necesidad

  3. dired, un practico navegador de ficheros, con el que puedes hacer lo mismo que con un navegador grafico, solo que incorporado, sin tener que transitar a una aplicacion externa, con los beneficios que esto conlleva

  4. bookmarks, tanto para una ruta especifica del sistema, como para una posicion dentro de un fichero de texto. Evitar escribir y recordar rutas, es muy liberador y comodo

  5. anillo de la muerte, es como un portapapeles donde todo el texto que cortes o indicas expresamente se guarda de forma “circular”, por supuesto, su comportamiento y presentacion pueden adaptarse para ser mas agradable (para mi ya es agradable)

  6. anillo de marcas, esto es un registro de la posicion donde se realizan ciertas acciones, lo que te permite ir de un sitio a otro del dcumento/lo-que-sea y regresar a la posicion de partida sin buscar a lo bruto

  7. registros, es algo a medio camino entre el anillo de la muerte y el de marcas, la diferencia esta en que “guardas” especificamente el contenido/posicion en un “registro”

  8. busqueda, substitucion, busqueda-regexp y substitucion regexp. Lo primero es practico, lo segundo extremadamente poderoso, aunque al igual que la mayoria de motores de expresiones regulares la escritura es algo tortuosa

  9. buffers, windos, frames. Esto es una terminologia propia de Emacs, lo primero es lo que se muestra en los “tabs” (windows), lo segundo los “tabs”, los cuales pueden habitar varios en la misma “ventana” (frame) con cualquier contenido y posicion, una independiente de otra y lo tercero los frames son las “ventanas”… y esto sirve por ejemplo para tener un proyecto de programacion repartido en 3 areas de trabajo a dos monitores cada una con su “frame” de emacs (todos conectados) con ficheros varios o repetidos con distintas posiciones, algunas en la misma “ventana” dividida para maximisar el espacio… como lo que hacen com multiples terminales en la misma ventana, perooo util de verdad…

  10. ejecucion de comandos del sistema. Estos pueden alimentarse con texto y mostrar, depositar o substituir otro texto. Util por ejemplo para hacer un sort y un uniq en una region especifica de un documento cualquiera

  11. macros, junta los ultimos 6 puntos, agrupalos en una secuencia de acciones repetitiva, y vuala! algo a medio camino entre la automitizacion y lo manual, por ejemplo para transformar una documento de un formato a otro, o crear informacion, corregirla o todo junto

  12. org-mode, esto es un lenguaje de marcas ligeras con los poderes especiales de Emacs, que sirve para muchas cosas, como para escribir un blog, como para hacer una lista de pendientes, o escribir un libro. Cierto es que ya no lo utilizo tal cual, pero fue inspiracion base de como debe ser el sistema de documentacion ideal, tambien lo utilzo para registrar la musica que escucho y anotar lo que hago en el dia

  13. eww, un navegador de internete y tambien visor de html, muy potable, de hecho el mejor navegador en modo texto de los que he probado, tambien incluye sus propios marcadores

  14. magit (requiere instalacion). La mas comoda y vistosa herramienta para interactuar con repositorios git

  15. elfeed (requiere instalacion). El mas bonito visor de feeds, si lo sumamos con el navegador, o que puede invocar al navegador del sistema, optienes el combo perfecto

  16. un gestor de paquetes para instalar extenciones sin mucha complicacion/configuracion

asi que por estas razones deberias empezar a aprender emacs hoy, para haci quisa dentro de unos pocos meses o años alguien se digne a traducir el colosal manual de emacs al español…

(tambien tiene corrector ortografico, que por cierto nunca utilizo)

Por donde empiezo

Primero instala emacs, seguro que viene en los repositorios, Luego cuando lo abras por vez primera presiona Ctrl-h t (control y h a la vez y luego t) esto abre un breve tutorial suficiente para iniciar

Luego cambia el tema para que no te quedes ciego y despues pues ver la compilacion de recursos que ha hecho Quijote Libre; al igual que el, recomiendo la saga emacs de la pipaplena, como tambien algunos post (no muy organizados) en el binario.net, darse una vuelta por el planet emacs en español y sus blogs afiliados, que es de lo poco realmente vivo en la comunidad Emacs-hispana

hace mucho, mucho tiempo, pero no tanto, existio una pagina llamada rpublica.net, sitio donde existia un exelente y aun vigente curso de iniciacion a emacs, al que por su calidad realice un wget y por bagancia no he “limpiado” para rendirle tributo, podeis descargar un zip con su contenido aqui, descomprimir y abrir el fichero emacs.html con el navegador

tambien dejo una pequeña chuleta que hice en mis primeros dias y aun me sigue siendo util chuleta-emacs, puedes ponerla en un marcador, por ejemplo de nombre keys y darle una exencion org y conquistar el mundo

como consejo final, substituye al menos block-mayus por Control, o como en mi caso tengo una configuracion customizada del mapeo programmer dvorak-en, en un teclado con distribucion en ingles

si no has aprendido mecanografia haslo, y si ya sabes y es con qwerty, cambiar vale cada hora requerida. Modificar la posicion de Ctrl, evita extraños estiramientos no solo en Emacs, tambien en el resto de programas

desconosco si el mapeo de programmer dvarak-en es igual en todos los SOs, al menos en freidora (y creo que tambien en debian) biene cargada de muchos caracteres extra al presionar alt gr, por ejemplo, en conjunto con la n, te da la ñ, y con comilla simple, pones acentos

-1:-- Por que GNU Emacs? (Post )--L0--C0--July 02, 2017 05:26 PM

Maxxcan's Site: Programación literaria para Devops con Emacs (1 parte)

programación literaria
  Aquí os dejo mi conferencia sobre Programación Literaria para Devops. Posteriormente subiré el material…
-1:-- Programación literaria para Devops con Emacs (1 parte) (Post admin)--L0--C0--June 13, 2017 10:17 AM

Bad Daemons: Ansible en emacs

Ultimamente 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 Contínua. 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-vault-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 indentació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 semacs, 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 '(lambda () (ansible-doc-mode)))
  (progn
    (save-window-excursion (ansible-doc "a10_server"))
    (kill-buffer "*ansible-doc a10_server*")))

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 ~/.vaut_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 habria que poner algo como esto:

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

La configuración del modo en si es la siguiente:

(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 facil 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.

-1:-- Ansible en emacs (Post drymer)--L0--C0--June 06, 2017 06:16 PM

Quijote Libre: Aprendiendo GNU Emacs y org-mode (VIII)

“Capturar” en org-mode Una de las principales facilidades que me he encontrado en GNU Emacs, y en particular en org-mode, es la sencillez de almacenar la información en texto plano. Así que para intentar quitarme el mono y recuperar ritmo vamos hoy a ver una importante funcionalidad de org-mode, sin profundizar demasiado en ella eso […]
-1:-- Aprendiendo GNU Emacs y org-mode (VIII) (Post Quijote Libre)--L0--C0--June 03, 2017 12:24 PM

Bad Daemons: Ejecución asíncrona de bloques babel en org-mode

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:

no-async-babel.gif

async-babel.gif

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/"
  :config
  (add-to-list 'org-ctrl-c-ctrl-c-hook 'ob-async-org-babel-execute-src-block))

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.

-1:-- Ejecución asíncrona de bloques babel en org-mode (Post drymer)--L0--C0--May 28, 2017 09:23 AM

uGeek: 025. Metodo mas completo para recopilar notas, org Mode

Publicado por Angel

Suscribete al Blog : RSS del Blog

Suscribete al Podcast : RSS , ITunes , ivoox



Aplicación para Android: http://www.orgzly.com/
Aplicación multiplataforma de PC: https://www.gnu.org/software/emacs/

Este es el método definitivo, hasta ahora, para tomar mis notas con un sistema jerárquico de  notas y todas dentro en un único txt, renombrado como .org.
Os recomiendo que le deis una oportunidad, porque estoy seguro que os gustará.

Tags: , emacs , podcast ,

<noscript>Please enable JavaScript to view the <a href="https://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>
-1:-- 025. Metodo mas completo para recopilar notas, org Mode (Post )--L0--C0--March 08, 2017 12:00 AM

La Pipa Plena: Curso emacs 23. Presentaciones con beamer

En esta entrada veremos como crear una presentación con beamer a partir de un archivo org. Para no andar dejando archivos esparcidos por cualquier parte, creamos un directorio de trabajo y en su interior colocamos el archivo presentacion.org: $ mkdir beamer $ touch beamer/presentacion.org Para hacer lo mismo también puedes emplear dired: M-x d RET
-1:-- Curso emacs 23. Presentaciones con beamer (Post templix)--L0--C0--March 05, 2017 04:37 PM

La Pipa Plena: Curso emacs 22. Personalizar la linea de modo y el minibuffer

En esta entrada veremos como personalizar un poco la linea de modo y el minibuffer. Sin ningún tipo de modificación, la linea de modo puede lucir más o menos así: Añadiendo a nuestro archivo de configuración .emacs las siguientes lineas: (setq-default mode-line-format (list " %2 " mode-line-modified " %2 %f %4 [%l:%p] " " %4
-1:-- Curso emacs 22. Personalizar la linea de modo y el minibuffer (Post templix)--L0--C0--February 24, 2017 03:42 PM

La Pipa Plena: Curso emacs 21. Postámbulos y algo sobre imágenes en org-mode

Por defecto, el postámbulo que aparece en un html que ha sido exportado de un archivo org, coge los datos del sistema y consta del nombre del autor (author), la fecha (timestamp), las versiones de emacs y org-mode (creator) y el link de validación del código. Si queremos especificar más datos de las mencionados o
-1:-- Curso emacs 21. Postámbulos y algo sobre imágenes en org-mode (Post templix)--L0--C0--February 18, 2017 06:22 PM

nba - GNU's Rock: no mas tabs en go-mode

Go tiene una ridicula guia de estilo para formatear codigo que no me agrada, de no seguir algunas reglas el compilador/interprete simplemente se niega a hacer nada. Otras reglas, son menos rigurosas, como la indentacion o colocar o no espacios, en algunos sitios.

La indentacion oficial del lenguaje, tiene tabs equivalentes a 4 espacios en blanco y eso, eso, es algo que no puedo soportar, como tampoco tener tabs, porque cada editor los despliega como le viene en gana.

Por eso, dentro de la configuracion de emacs tengo esta linea

(setq-default indent-tabs-mode nil)

su funcion es substituir los tabs por espacios, y en el modo go tenia esta modificacion

(add-hook 'go-mode-hook
          (lambda ()
            (setq tab-width 2)))

para que los tabs se representen como dos espacios en blanco.

Perfecto! subo un repositorio de codigo en go a github y por curiosidad veo el codigo ya en el repo… la indentacion es un jodido desastre! los tabs son tabs… pero, pero, si en el jodido modo go, todo se ve perfecto, que esta pasando es cosa de github o un problema interno?

paso a abrir el codigo en emacs y cambio a fundamental-mode para visualizar la realidad, resultado, el problema esta en go-mode, en efecto los tabs se visualizan como 2 espacios, pero en el fichero no se substituyen por espacios, siguen siendo tabs, donde esta el culpable?

paso a ver el codigo de go-mode, en busca de expresiones regulares y cosas como \t… no encuento el problema (y tampoco entiendo mucho de lisp)… entonces cambio la busqueda a cosas que contengan la palabra indent y aparece esta linea

  ;; Go style
  (setq indent-tabs-mode t)

(commit 5737e59cbac9bc480546766c9502c527fa2be26f, linea 985)

Su funcion es dejar los tabs como tabs y no como espacios, la solucion? cambiar t por nil directamente en el codigo de go-mode.el o en un hook en la configuracion.

(add-hook 'go-mode-hook
          (lambda ()
            (setq indent-tabs-mode nil)
            (setq tab-width 2)))

ahora, si abres tu codigo los cambios se realizan solo a las lineas que modifiques, no a las lineas ya existentes. Es necesario reeindentar todo y no funciona C-x h tab, hay que quitar la indentacion e indentar de nuevo, hice una macro que recorria todas las lineas eliminando los espacios al inicio, luego si seleccione todo + tab (C-x h tab).

Tabs y espacios en armonia!

-1:-- no mas tabs en go-mode (Post )--L0--C0--February 13, 2017 03:52 AM

La Pipa Plena: Curso emacs 20. Gráficos con org-mode (ditaa y plantuml)

En esta entrega veremos como crear gráficos con org-mode para que al exportar a html se vean aparentes. En primer lugar, caso de no tenerla instalada, instalamos la aplicación ditaa (apt-get install ditaa), aplicación que transforma caracteres ascii en mapas de bips. Una vez instalado en el sistema, abrimos emacs y visualizamos su página man:
-1:-- Curso emacs 20. Gráficos con org-mode (ditaa y plantuml) (Post templix)--L0--C0--February 05, 2017 03:07 PM

nba - GNU's Rock: org mode

org-mode es un lenguaje de marcas ligeras nacido de, por, y para emacs y como emacs, org tambien tiene aplicaciones varias, puede ser una agenda, una lista de pendientes, hoja de calculo, blog de notas, sistema de documentacion e investigacion reproducible, todo junto y revuelto, encima da la posibilidad de exportar el contenido a pdf, latex, html, markdown, odt y groff (algunas opciones vienen por separado y requieren configuracion).

que bueno… no? la devilidad de org esta en su diversidad, al no tener un proposito especifico, algunos aspectos no han sido resueltos, especialmente lo que respecta a ser un sistema de documentacion. Con todo, si no exiges demasiado vasta y sobra.

Imaginemos que no conoces org, odias html y tienes necesidad de generar contenido en formato html, listo?, de eso va esta entrada

Configuracion

Para comenzar a utilizar org solo hace falta abrir emacs y crear un fichero con terminacion .org o en su defecto agregar lo siguiente en la primer linea de cualquier fichero y recargar (C-x C-v)

-*- mode: org; -*-

org utiliza unas marcas especiales (opcionales) al inicio del documento, para establecer el titulo, autor, correo, encender y apagar algunas caracteristicas.

#+TITLE: Cosas de Emacs: org-mode
#+LANGUAGE: es
#+AUTHOR: nasciiboy
#+EMAIL: miCorreoCamello@aya.org
#+DATE: 2015-22-06
#+DESCRIPTION: experimento org-mode
#+KEYWORDS: emacs org-mode tutorial

supongo que se explican por si mismas…

Encabezados

Cualquier cosa que escribamos inmediatamente despues de la configuaracion, sera lo primero que aparezca dentro del documento, aunque, al igual que en html, tambien podemos agrupar el contenido dentro de secciones/encabezados segun convenga.

La sintaxis de un encabezado es muy simple:

* Encabezado principal
** Segundo nivel
*** 3er. nivel
    algo de texto
*** 3er. nivel
    mas texto

* Otro encabezado principal

Toda linea que inicia con uno o varios * seguido por al menos un espacio en blanco, es un encabezado.

El texto (en la misma linea) donde esta el o los * sera el titulo del encabezado.

El nivel del encabezado depende del numero de * al inicio de la linea, es decir

  • * == h1
  • ** == h2
  • *** == h3
  • **** == h4
  • ***** == h5

(en realidad, al exportar a html, los encabezados se desplazan en uno, el titulo del documento es el que se corresponde con h1, pero lo dejo asi para evitar esfuerzo mental)

A que encabezado pertenece el texto? al primero que aparezca por encima de el. Si no tiene un encabezado encima pertenece al titulo del documento

NOTA: en org no existe un limite en cuanto a el nivel que puede tener un encabezado. No es asi en html, segun recuerdo el encabezado de menor nivel que existe en html es h7

Un ejemplo mas extenso:

* Encabezado H1

  Primer parrafo del encabezado H1

  Segundo parrafo del encabezado H1

** Encabezado H2

   Algo,
   y algo mas (sin una linea en blanco no hay cambio de parrafo)

** Otro Encabezado H2

   Hey

*** Encabezado H3

    coloca algo aqui

**** Encabezado H4

     y aqui

***** Encabezado H5

      tambien aqui

* Otro Encabezado H1

como vez, he indentado el texto que pertenece a cada encabezado (no es necesario, pero a mi me gusta que se vea asi).

Por cierto como no podia ser de otra forma podemos crear encabezados haciendo uso de atajos de teclado.

Con M-Intro si no hay ningun encabezado, aparece uno de primer nivel, de otra forma, el nivel es igual al del encabezado anterior.

otros atajos interesantes

  • TAB sobre un encabezado, oculta o muestra el contenido

  • Shift-TAB En cualquier posicion, oculta o muestra el contenido de todos los encabezados

  • C-c C-n ir al siguiente encabezado

  • C-c C-p ir al encabezado anterior

  • C-c C-f ir al siguiente encabezado del mismo nivel

  • C-c C-b ir al encabezado anterior del mismo nivel

  • C-c C-u ir al encabezado padre

  • M-FlechaDerecha agregar un * al encabezado

  • M-FlechaIzquierda quitar un * al encabezado

  • M-FlechaArriba Si el encabezado superior es del mismo nivel, intercambia el lugar de los encabezados, es decir mueve el actual hacia arriba

  • M-FlechaAbajo Si el encabezado siguiente es del mismo nivel, intercambia el lugar de los encabezados, es decir mueve el actual hacia abajo

Listas

Como en html, disponemos de dos tipos de listas, ordenadas (numeradas) y no ordenadas, para las primeras colocamos un numero (el que sea) seguido de un punto y comenzamos a escribir

1. primer elemento de la lista
2. segundo elemento de la lista
3. tercer elemento de la lista
   con una linea adicional

   este parrafo tambien es parte del tercer elemento


este parrafo esta fuera de la lista

en este caso, el contenido que sea parte de un elemento de la lista, debe respetar cierta indentacion.

El numero que coloques al inicio de la lista, es irrelevante, org lo ignora por completo y lo substituye por un ol -> li al exportar.

Como en los encabezados, podemos generar-saltar al siguiente elemento con la combinacion M-Intro. Este atajo tiene un efecto secundario, org pasa de nuestro numero y reenumera la lista apartir de 1.

Para salir de la lista, dejamos una linea en blanco. Org tambien considera, de forma automatica que estamos fuera de un listado si dejamos dos espacios en blanco.

Si estamos dentro de un parrafo y alguna de sus lineas tiene apariencia de listado al exportar, org toma la linea y la considera una lista. No tengas lineas que inicien con algo similar a una lista.

El resto, asi son las listas ordenadas

1. elemento uno
2. elemento dos
3. elemento tres


1) elemento uno
2) elemento dos
3) elemento tres

listas no ordenadas

+ elemento uno
+ elemento dos
+ elemento tres


- elemento uno
- elemento dos
- elemento tres

Algunos comandos en listados

  • Shift-FlechaDerecha rotacion por el estilo del listado

  • M-FlechaIzquierda rotacion por el estilo del listado

  • M-FlechaDerecha convierte al elemento en un miembro del elemento superior

  • M-FlechaIzquierda convierte al elemento en un elemento de nivel superior

  • M-FlechaArriba si el elemento superior es del mismo nivel, intercambia el lugar de los elementos, es decir mueve el actual hacia arriba

  • M-FlechaAbajo si el elemento siguiente es del mismo nivel, intercambia el lugar de los elementos, es decir mueve el actual hacia abajo

Definiciones

Este elemento tiene las mismas reglas que una lista no ordenada, es decir, el contenido que forme parte de la definicion ha de tener indentacion.

+ Palabra :: definicion

- Palabra :: definicion

los dos puntos (::) que separan la palabra de la definicion tiene que estar en la misma linea que el signo - o +. La definicion puede extenderse en varias lineas, parrafos e incluir bloques varios.

Al igual que una lista, las definiciones terminan dejando dos linas en blanco.

Resaltado

  • *bold* ==> bold
  • ~code~ ==> code
  • +strike+ ==> strike
  • /italic/ ==> italic
  • =verbatim= ==> code
  • _underline_ ==> underline

tambien se pueden crear superindices

elemento^superinidice

el elemento y el superindice no deben tener espacios en blanco, por ejemplo

  • 2^30 ==> 230

en caso de los subindices

elemento_subinidice

el elemento y el subindice no deben tener espacios en blanco, por ejemplo

  • 2_30 ==> 230

finalmente podemos meter formulas LaTex dentro del texto (inline) con la sintaxis $formula$, por ejemplo

  • $ne^{123^{a}}$ ==> ne123a

Enlaces

[[prefijo:ruta][descripcion]]

la descripcion puede omitirse, quedando

[[prefijo:ruta]]

enlaces soportados

http://www.astro.uva.nl/~dominik          en la red
doi:10.1000/182                           DOI para un recurso electronico
file:/home/dominik/images/jupiter.jpg     fichero, ruta absoluta
/home/dominik/images/jupiter.jpg          igual que arriba
file:papers/last.pdf                      fichero, ruta relativa
./papers/last.pdf                         igual que arriba
file:/myself@some.where:papers/last.pdf   fichero, ruta a una maquina remota
/myself@some.where:papers/last.pdf        igual que arriba
file:sometextfile::NNN                    fichero, saltar al numero de linea
file:projects.org                         otro fichero Org
file:projects.org::some words             buscar texto en fichero Org[fn:35]
file:projects.org::*task title            buscar encabezado en fichero Org[fn:36]
file+sys:/path/to/file                    abrir via OS, como doble-click
file+emacs:/path/to/file                  fuerza apertura con Emacs
docview:papers/last.pdf::NNN              abrir en modo doc-view en la pagina
id:B7423F4D-2E8A-471B-8810-C40F074717E9   Enlazar con ecabezado por ID
news:comp.emacs                           enlace Usenet
mailto:adent@galaxy.net                   enlace Mail
mhe:folder                                enlace a carpeta MH-E
mhe:folder#id                             enlace a mensage MH-E
rmail:folder                              enlace a carpeta RMAIL
rmail:folder#id                           enlace a mensaje RMAIL
gnus:group                                enlace a grupo Gnus
gnus:group#id                             enlace a articulo Gnus
bbdb:R.*Stallman                          enlace BBDB (con regexp)
irc:/irc.com/#emacs/bob                   enlace IRC
info:org#External links                   enlace a nodo o indice Info
shell:ls *.org                            Un comando shell
elisp:org-agenda                          Comando Interactivo Elisp
elisp:(find-file-other-frame "Elisp.org") formate de evaluacion Elisp

Ademas podemos poner enlaces a secciones (encabezados) dentro de nuestro documento con la estructura

[[*Encabezado][descripcion]]

recuerda, la descripcion es opcional

Si te encuentras en el modo org, y deseas segir un enlace presiona C-c C-o. Para regresar a la posicion original C-c &.

Tambien puedes colocar una marca temporal C-c % y luego regeresar con C-c &. Esto es similar al comando C-u C-ESP que permite recorrer el circulo de marcas.

Para modificar la direccion de un enlace o su descripcion presiona C-c C-l

Por cierto, para colocar imagenes dentro del contenido que exportes simplemente coloca la direccion de la imagen, asi:

[[mi-imagen.png]]

Radio Targets

Los Radio Objetivos, son un metodo automagico de convertir una frace en un enlace a algun punto del documento, lo unico que tenemos que hacer es encerrar el objetivo entre tres pares de < > asi:

<<<Mi objetivo>>>

ahora todo el texto que coincida con Mi objetivo apunta al radio objetivo, no importa si esta separado por espacios (exepto nuevas lineas) o si esta en minusculas o mayusculas.

Codigo

Org tiene distintos tipos de bloques, todos con esta sintaxis

#+BEGIN_Tipo-Bloque algun-parametro
  contenido
#+END_TIpo-Bloque

donde Tipo-Bloque puede ser

  • EXAMPLE ejemplos (como <pre>)
  • HTML seccion de codigo a exportar tal cual
  • LaTex seccion de codigo a exportar tal cual
  • SRC bloque de codigo
  • QUOTE bloque de cita

hay un truco, que evita escribir a mano todo el bloque. En una linea vacia o con espacios en blanco escribimos < segudio por

  • e ==> EXAMPLE
  • h ==> HTML
  • l ==> LaTex
  • s ==> SRC
  • q ==> QUOTE

y mas un tab el bloque aparece!

Es necesario ahondar un poco en los bloques de codigo fuente

#+BEGIN_SRC c
  /* strlen: regresa la longitud de s */
  int strlen(char s[])
  {
    int i;

    i = 0;
    while (s[i] != '\0')
      ++i;
    return i;
  }
#+END_SRC

el lenguaje se especifica luego de #+BEGIN_SRC, en este caso, lenguaje c, tambien podemos hacer que el codigo aparesca numerado, si agregamos el parametro -n. Si se desea que la numeracion inicie a partir de un numero concreto colocamos -n numero.

Antes mencione que org nacio de, por y para emacs, pues resulta que esto se demuestra en los bloques de codigo. Sea cual sea el lenguaje que coloques delante de un bloque de codigo (digo, si esta soportado) al presionar C-c ' se abre un buffer con un modo para editar dicho lenguaje con resaltado, con teclas de emacs y funciones de emacs. Otro C-c 'te regresa al documento.

Puedes imaginar el colosal esfuerzo que requiere emular esta funcion en otro sitio que no sea emacs?

asi se ve org-mode en mi emacs

NOTA: a veces en versiones experimentales de emacs, la convinacion C-c ' abre un buffer de edicion para el bloque de codigo, pero al repetir el comando, este no se reconoce, si ocurre esa situacion, intenta con los comandos por su nombre directamente. Para entrar es org-edit-src-code y para salir org-edit-src-exit

Exportacion

En principio, exportar apartir de org es sencillo, presionamos C-c C-e.

Esto abre una interfaz de exportacion con opciones varias, por ejemplo para exportar a html (un fichero con el mismo nombre del documento pero con terminacion .html) el comando completo seria C-c C-e h h, o si estas ya en la interfaz Org Export Dispatcher, solo h h.

Pero antes de exportar vamos a modificar algunas cosas. En la configuracion del documento agrega estas lineas:

#+OPTIONS: toc:nil num:nil h:7 html-preamble:nil html-postamble:nil html-scripts:nil html-style:nil
#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="worg-data/worg.css" />

#+HTML_HEAD: coloca alguna cosa dentro de la etiqueta head del html, para ser precisos, se indica la direccion de una hoja de estilo. Aqui encontraras la que utilizo.

cuando se exporta por defecto, se crea una tabla de contenidos, si no la quieres deja el toc:nil, tambien se numeran las secciones, como 1, 1.1, 2, 2.1.2 y asi, num:nil indica que no queremos numeracion.

h:7 indica cuantos niveles de encabezados deseamos exportar como Hs. Si hay encabezados que superen el nivel, seran incluidos, pero en forma de lista.

html-postamble:nil elimina una seccion al final del html que contiene el autor, fecha y correo(?), html-preamble-nil no se que haga pero tampoco lo quiero…

veras que org es generoso, nos regala una hoja de estilo y scripts html-scripts:nil y html-style:nil se las regresan… de buena forma… pero org insiste, pasa de nosotros y las coloca de todas formas (por lo general, como comentario)

por cierto, para mostrar las formulas LaTex en html, org coloca por su cuenta esta linea

<script type="text/javascript" src="http://orgmode.org/mathjax/MathJax.js"></script>

Colorear Codigo (al exportar)

Esto requiere algo de codigo (ha, ha, ha…), primero ve a tu carpeta de configuracion. En mi caso es

cd ~/.emacs.d/plugins/

luego

git clone https://github.com/emacsmirror/htmlize.git

y agrega esto en tu archivo de configuracion

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE: org-mode             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; source: https://github.com/emacsmirror/htmlize.git
(load-file "~/.emacs.d/plugins/htmlize/htmlize.el")

;; esto activa el coloreado
(setq org-src-fontify-natively t)

;; por defecto se coloca el color en linea, descomenta
;; si quieres este comportamiento
;; (setq org-html-htmlize-output-type 'inline-css)

;; en mi caso prefiero tomar el estilo de una hoja css
;; comenta si eliges lo anterior
(setq org-html-htmlize-output-type 'css)

;; las siguientes lineas son para colocar o no un prefijo a
;; las etiquetas de codigo (todas son de tipo <span>)
;; (setq org-html-htmlize-font-prefix "") ;; default
(setq org-html-htmlize-font-prefix "src-")

podria interesarte saber que puedes convertir cualquier buffer de emacs, en una pagina html. El comando es htmlfontify-buffer.

Al parecer, htmlize es una vesion vieja del modo htmlfontify (incluido por defecto), a saber por que org requiere de htmlize

Cosideraciones adicionales

org, y otros lenguajes de marcas ligeros tiene carencias severas de base, no solo por utilizar signos comunes para el resaltado, lo que proboca que en ocaciones se interprete de manera inesperada el resaltado o simplemente no se interpreta. Tambien estamos limitados a 4-5 opciones de resaltado.

Segun el manual, podemos evitar comportamientos extraños escapando caracteres con \ peeeero esto no funciona del todo bien. Como alternativa se ofrece escribir simbolos al estilo LaTex \nombre-simbolo peeero esto tampoco funciona del todo bien.

en mi caso paso del resaltado y lo desactivo con la opcion *:nil, para eliminar la interpretacion de (super|sub)indices ^:nil

para poner etiquetas html directamente

@@html:lo-que-sea@@texto@@html:lo-que-sea@@

por ejemplo

@@html:<b>@@texto@@html:</b>@@

je, je, je… que comodo!

Si estas creando un documento en partes para incluir las secciones, coloca esta linea en la posicion donde debe aparecer el contenido de otra seccion

#+INCLUDE: "~/my-book/chapter2.org" :minlevel 1

Para terminar Org tiene muchos atajos, la mayoria con prefijo C-c que supuestamente es el espacio donde el usuario (y los modos) define(n) sus propios comandos. Como resultado tus comandos seran ignorados. La solucion? pues yo pase mis comandos a s-c (Super-c).`

Recursos, Enlaces y Fuentes

Org es amplio, tanto que tiene un manual-libro incluido dentro de emacs en el modo info, date una vuelta que no muerde

-1:-- org mode (Post )--L0--C0--January 31, 2017 08:40 PM

Maxxcan's Site: Qué hacer después de instalar Emacs (3ª parte)

Qué hacer después de instalar Emacs (3ª parte) Seguimos con la última parte de nuestra introducción…
-1:-- Qué hacer después de instalar Emacs (3ª parte) (Post admin)--L0--C0--January 24, 2017 01:35 PM

La Pipa Plena: Curso emacs 19. impatient-mode, writeroom-mode, capturas y memoria en uso.

En esta ocasión veremos algunos paquetes interesantes que, en determinadas circunstancias, pueden sernos útiles. En ciertas ocasiones queremos compartir un buffer de emacs en nuestra red local y que además todos vean lo que estamos tecleando en tiempo real. Una forma fácil de realizar estas proezas es con la extensión impatient-mode. Este paquete precisa simple-httpd
-1:-- Curso emacs 19. impatient-mode, writeroom-mode, capturas y memoria en uso. (Post templix)--L0--C0--November 28, 2016 06:00 PM