Linux Sin Humo (Publicaciones sobre tutorials)

¿Cómo convertir tu configuración de init.vim a init.lua?

sebelk — Thu, 15 May 2025 19:01:18 GMT

Requisitos

Curiosidad. Es la condición más importante para leer este post. Si la tenés, con algo de esfuerzo sumado a algo de tiempo podrás aprender Vim, Neovim, etc.
Conocimientos básicos o intermedios de Vim y haber leído el post anterior.
Conocimientos básicos de vim-plug.

Repaso de conceptos importantes

En el post anterior vimos cómo un usuario de Vim puede comenzar a usar Neovim. En el presente artículo haremos la transición de Vim script a Lua. Ok, booting the post 😄 ...

Recordemos que Vim usa Vim script (aka VimL) como lenguaje de scripting nativo. Es un lenguaje específico que permite personalizar y extender su funcionalidad. Existe en dos formas: el Vim script tradicional (también llamado "legacy script") y Vim9script (introducido en Vim 9.0), que ofrece mejor rendimiento y una sintaxis más moderna. Sin embargo, Vim9script ni siquiera se usa de manera predeterminada en Vim 9.

Lua, en cambio, es un lenguaje de programación ligero, de alto nivel y multiparadigma, diseñado principalmente para ser incorporado en aplicaciones. Se destaca por su simplicidad, eficiencia y portabilidad. Neovim incorporó Lua como lenguaje de scripting de primera clase, lo que ha ganado popularidad debido a su mejor rendimiento y facilidad de uso comparado con Vim script tradicional.

Neovim usa una implementación de Lua llamada LuaJIT, que compila código Lua a código máquina nativo durante la ejecución. Es un detalle técnico relevante, pero no la razón principal para preferir Lua sobre Vim script en la configuración del editor — en ese terreno el cuello de botella suele estar en el startup time y en el diseño de los plugins, no en la velocidad del lenguaje.

Diferencia de idiosincrasia:

Vim script: scripting lineal, global y directo. Bueno para pequeños ajustes, pero difícil de escalar.
Lua (Neovim): lenguaje estructurado, orientado a modularizar, reusar y escalar. Favorece el uso de variables locales, tablas y funciones que mejoran el mantenimiento de la configuración.

Por qué importa esto en la práctica:

La API de Neovim en Lua es estructurada y predecible (tablas, namespaces como vim.api.*, vim.opt), donde Vim script ofrecía variables globales y comandos planos.
El ecosistema de plugins modernos asume Lua como lenguaje nativo — los gestores actuales (lazy.nvim, packer.nvim), los runtime helpers, los plugins de LSP y UI conviven mejor con configs en Lua.
La modularización con require permite dividir la configuración en archivos lógicos con scoping limpio, algo que Vim script soporta de forma rudimentaria.

LuaJIT existe y es rápido, pero esa rapidez rara vez es lo que el sysadmin nota al usar Neovim — lo que nota es que su configuración escala mejor y se integra con el ecosistema sin fricciones.

3 conceptos esenciales — lo mínimo que siempre debés recordar

Concepto	Por qué es esencial
Tablas (`table`)	Las tablas son la única estructura de datos compuesta en Lua. Opciones (`vim.o`, `vim.opt`), autocmds, comandos, mappings y configuraciones de plugins.
Variables locales (`local`)	Permiten organizar el código, evitar errores y mejorar el rendimiento. Imprescindible para no contaminar el entorno global.
*API de Neovim (`vim.api.`)**	Es la manera oficial y flexible de interactuar con Neovim: crear comandos, autocmds, mappings y manipular el editor desde Lua.

Si entendés estos 3 conceptos, podés crear y mantener cualquier configuración básica y muchas avanzadas.

¿Qué es una tabla y qué no en la configuración de Neovim (Lua)?

Tablas 🆗:

vim.g
vim.opt / vim.o
vim.api
Configuraciones de plugins
Listas/patrones

No son tablas ⚠:

Funciones
Comandos ejecutados
Strings, números, booleanos

El podio de las tablas globales más importantes en Neovim

Estas son las tres tablas globales más importantes del entorno Lua en Neovim:

🏅 vim

Es la tabla principal y núcleo del entorno Lua en Neovim. Contiene todo lo necesario para interactuar con el editor:

Subtablas como vim.api, vim.cmd, vim.opt, vim.g, vim.fn, etc.
Siempre disponible sin necesidad de importar.

🥈 _G

Es la tabla global del lenguaje Lua. Desde aquí podés definir funciones o variables globales accesibles desde cualquier parte de tu configuración:

_G.mi_funcion = function() ... end
También contiene vim como una de sus claves.

🥉 package (de Lua)

Maneja los módulos cargados por require. Es crucial para modularizar tu configuración:

package.loaded permite ver y recargar módulos.

Nota

Tablas como vim.api, vim.opt, vim.g son importantes, pero no son globales de nivel superior: viven dentro de vim. Lo mismo aplica para math, string, table, etc., que viven en _G.

→ Estas 3 (vim, _G, package) forman la base del entorno ejecutable de cualquier configuración Neovim moderna en Lua.

Subtablas más importantes

Tabla	Contiene	Ejemplo equivalente en Vim script
`vim.o`	Opciones globales	`set tabstop=4`
`vim.opt`	Acceso a opciones con métodos (`:append`, `:remove`, `:prepend`); requerido para listas	`set nrformats+=alpha`
`vim.cmd`	Comandos que se ejecutan en modo ex	`colorscheme PaperColor`
`vim.g`	Variables globales	`let g:loaded_perl_provider = 0`
`vim.keymap.set`	Asignación de atajos de teclado a una función o combinación de teclas	`nnoremap ñ :wq<CR>`
`vim.api.nvim_create_user_command`	Creación de comandos personalizados	`command Nbuild execute 'w \| Silent nikola build'`

Diccionario cruzado Vim script / Lua

Concepto	Vim script	Lua
Variable global	`let g:mi_var = 10`	`vim.g.mi_var = 10`
Variable local	`let l:var = 10` (function-local), `s:`, `b:`, `w:` por contexto	`local var = 10`
Lista	`let lista = [1,2,3]`	`lista = {1, 2, 3}`
Diccionario	`let dict = {'a':1}`	`dict = {a = 1}`
Función	`function! Hola() ... endfunction`	`function hola() ... end`
Función anónima	`{a, b -> a + b}` (lambda, desde Vim 8.0)	`function() ... end`
Autocomando	`autocmd BufWrite ...`	`vim.api.nvim_create_autocmd`
Mapping	`nnoremap`	`vim.keymap.set`
Comando	`command ...`	`vim.api.nvim_create_user_command`

Ejemplo de migración Vim script → Lua

Bueno, con la teoría suficiente, ✋✋ a la obra 😉. Supongamos que tenemos esta configuración del archivo init.vim:

set tabstop=4
set nrformats+=alpha

nnoremap ñ :wq<CR>

command -nargs=+ Silent execute 'silent !<args>' | redraw!
command Nbuild execute 'w | Silent nikola build'

filetype plugin on
runtime plugins.vim
colorscheme PaperColor

Es un archivo pequeño, pero que sirve de punto de partida para moverse a una configuración en Lua.

Crear el entorno para Neovim

Como vimos en el post anterior, mi recomendación es comenzar con un archivo init.vim. Una vez que ya estamos usando Neovim podemos realizar la migración a init.lua. Sin embargo, tenemos que crear los directorios para que Neovim guarde su configuración. Lo único que dejaremos por ahora en Vim script es la configuración de plugins con vim-plug. Por lo tanto ejecutamos:

mkdir -p ~/.config/nvim/lua/utils
mkdir -p ~/.local/share/nvim/site/autoload
# Suponiendo que usabas un archivo para gestionar plugins en Vim
mv ~/.vim/autoload/plug.vim ~/.local/share/nvim/site/autoload

El directorio ~/.config/nvim es obligatorio.
El directorio ~/.config/nvim/lua no es obligatorio, pero es muy útil para modularizar la configuración de Neovim.
Los nombres dados de los archivos y directorios dentro de ~/.config/nvim/lua son totalmente arbitrarios.

En Neovim tendremos una estructura más modular. Si bien podemos tener todo en init.lua, vamos a aprovecharnos de esta configuración que es mucho más flexible.

Archivo ~/.config/nvim/init.lua

-- Cargamos los plugins primero — algunas configuraciones
-- (como `colorscheme`) dependen de tenerlos disponibles en el runtimepath
vim.cmd('source ~/.config/nvim/plugins.vim')

-- Cargamos nuestros módulos (el require ejecuta el archivo;
-- el efecto viene del side-effect, no del valor capturado)
require('utils.commands')
require('utils.extracommands')
require('keymaps')
require('opciones')

Archivo ~/.config/nvim/lua/keymaps.lua

-- Alias
local map = vim.keymap.set
-- maps
map('n', 'ñ', ':wq<CR>')

Nota sobre vim.keymap.set: usa remap = false por default, así que map('n', 'ñ', ':wq<CR>') ya es equivalente a nnoremap (no a nmap). El "nore" que en VimL diferenciaba nnoremap de nmap está implícito en el default de la API Lua.

Archivo ~/.config/nvim/lua/opciones.lua

-- Alias
local vo = vim.o
local vop = vim.opt

-- Opciones
vo.tabstop = 4
vop.nrformats:append('alpha')

Archivo ~/.config/nvim/lua/utils/commands.lua

-- Comando auxiliar para correr cosas en shell silenciado
vim.api.nvim_create_user_command('Silent', function(opts)
  vim.cmd('silent !' .. table.concat(opts.fargs, ' '))
  vim.cmd('redraw!')
end, { nargs = '+' })

-- Build del sitio Nikola
vim.api.nvim_create_user_command('Nbuild', function()
  vim.cmd('w')
  vim.cmd('Silent nikola build')
end, {})

Archivo ~/.config/nvim/lua/utils/extracommands.lua

-- Alias
local vcmd = vim.cmd

-- Extra commands
vcmd('filetype plugin on')
-- Esta configuración es innecesaria porque ya está en init.lua
-- vcmd('runtime plugins.vim')
vcmd('colorscheme PaperColor')

Archivo ~/.config/nvim/plugins.vim

Este es el único archivo que dejamos en Vim script (con código Lua embebido):

"Plugins (Plug)
call plug#begin('~/.vim/plugged')

Plug 'itchyny/lightline.vim'
Plug 'nyngwang/NeoTerm.lua'
Plug 'NLKNguyen/papercolor-theme'

call plug#end()

lua << EOF                                                       
require("neo-term").setup {
  exclude_filetypes = { "oil" }
}                          
EOF

nnoremap <F4> :NeoTermToggle<CR>
tnoremap <F4> <C-\><C-n>:NeoTermToggle<CR>
tnoremap <Esc> <C-\><C-n>:NeoTermEnterNormal<CR>

Y listo...

Explicación

¿Por qué definimos alias en los archivos de módulos?

Los alias son básicamente variables. Los definimos porque este es un ejemplo de tipo "esqueleto" de configuración. Cuando comiences a agregar más opciones, atajos de teclado y comandos personalizados, no querrás tipear tanto 😉.

Nota sobre redefinición de comandos

vim.api.nvim_create_user_command sobrescribe por default un comando con el mismo nombre (la opción force tiene valor true por defecto, según la doc oficial de la API). Es decir: podés llamar dos veces a nvim_create_user_command('Nbuild', ...) y la segunda definición reemplaza a la primera sin error. No hace falta borrar antes con nvim_del_user_command. Esto es distinto del :command de VimL, que sí requiere command! para sobrescribir — la API Lua no hereda esa restricción.

El ejemplo de Nbuild deja ver diferencias más grandes entre VimL y Lua. Las analizamos en cinco dimensiones:

1. Brevedad vs mantenibilidad

VimL:

vim command -nargs=+ Silent execute 'silent !<args>' | redraw! command Nbuild execute 'w | Silent nikola build'

Es breve, directo y funciona. Pero:

Es poco expresivo
No permite manejar errores fácilmente
No escala bien con lógica compleja
Lua:

lua vim.api.nvim_create_user_command('Silent', function(opts) vim.cmd('silent !' .. table.concat(opts.fargs, ' ')) vim.cmd('redraw!') end, { nargs = '+' })

Es más verboso, sí, pero:

La función puede ser más compleja si se necesita
Es programable y reutilizable
Puede integrarse con condicionales, bucles, o lógica externa

2. Control de errores y depuración

En VimL: si un comando falla, tenés poco margen para capturar y manejar el error.
En Lua: podés usar pcall, vim.notify, vim.fn.systemlist, y construir mensajes personalizados o fallback si algo sale mal.

local ok, _ = pcall(function()
  vim.cmd('silent !nikola build')
end)
if not ok then
  vim.notify('Error al ejecutar nikola build', vim.log.levels.ERROR)
end

3. Modularización

En Lua podés agrupar comandos en módulos, con require(...).
En VimL tenés que recurrir a runtime, source, y no hay namespaces claros.

require('utils.commands')        -- registra los user commands al cargarse
require('utils.extracommands')   -- aplica colorscheme y filetype detection
require('keymaps')               -- registra los atajos de teclado
require('opciones')              -- opciones generales de configuración

Esto facilita dividir la configuración en archivos lógicos, más fácil de leer, mantener y compartir.

4. Compatibilidad futura y ecosistema Neovim

Neovim ha declarado que Lua es su lenguaje de configuración nativo moderno.
La mayoría de los plugins modernos están escritos en Lua.
VimL sigue siendo soportado, pero está siendo superado funcionalmente.

5. Legibilidad a largo plazo

Aunque VimL sea más corto, en un entorno de colaboración o con configuraciones grandes, Lua:
Es más explícito.
Permite documentar.
La API de Neovim en Lua permite un uso más explícito y predecible de tipos de datos.
Es más fácil de extender con lógica externa.

Conclusión

Si sabés migrar opciones, mappings, comandos y cargar plugins → podés convertir el 80% o más de tu init.vim (equivalente al viejo .vimrc) a init.lua.

Migrar de Vim script a Lua no es una mejora cosmética: cambia las posibilidades de la configuración. Lo que en Vim script son comandos breves, en Lua son funciones programables — más verbosas, sí, pero abiertas a control de errores con pcall, modularización con require y un ecosistema de plugins que ya asume Lua como lenguaje nativo.

La estructura mostrada acá es una entre muchas. El esqueleto init.lua + módulos en lua/ se sostiene porque escala: cada archivo crece sin contaminar al resto, y la configuración deja de ser una pared de líneas para volverse un conjunto de piezas que podés rearmar cuando lo necesites.

Lo que no migramos en este post es la configuración de plugins, que dejamos en plugins.vim. Reemplazar vim-plug por un gestor en Lua como lazy.nvim es el siguiente paso natural — y tema de este otro post.

Al cierre del post dejé un resumen de 10 conceptos clave para tener a mano cuando empieces a extender tu config.

Apéndice: Los 10 conceptos fundamentales de Lua (resumen)

Resumen de los 10 conceptos clave de Lua en Neovim. Los 3 marcados como (esencial) son los que vimos al principio; el resto extiende esa base:

Concepto	Descripción breve
Tablas (`table`) (esencial)	Estructuras clave-valor o listas. Base de toda la configuración.
Variables locales (`local`) (esencial)	Para mantener el código limpio y evitar contaminación global.
Funciones anónimas	Permiten definir acciones sin nombre, usadas en mappings, autocmds y comandos.
*API de Neovim (`vim.api.`)** (esencial)	Puente entre Lua y Neovim: crear comandos, mappings, autocmds.
`vim.opt` vs `vim.o`	`vim.o` da acceso directo al valor; `vim.opt` lo envuelve en un objeto type-aware con métodos (necesario para listas).
`require`	Para cargar módulos externos y dividir la configuración.
Paréntesis en llamadas	Obligatorio usar `()` al llamar funciones.
Referencias	Asignar una tabla a otra variable sin copiarla (ejemplo: `local vg = vim.g`).
`_G (global)`	Tabla especial que contiene las variables y funciones globales accesibles en toda la configuración.
`package.loaded`	Permite ver o manipular qué módulos están cargados, útil para recargar configuraciones dinámicamente.

Fuentes y más Recursos

Lua en Neovim (:help lua) — referencia completa de la API Lua de Neovim.
Guía de Lua para Neovim (:help lua-guide) — survival kit oficial para configurar Neovim en Lua.
Manual de referencia de Lua 5.1 — definición oficial del lenguaje (LuaJIT, que usa Neovim, está basado en esta versión).
Recursos de Lua recomendados por Neovim — curaduría oficial de tutoriales y libros.
A pragmatic approach to migrating from VSCode to Neovim — otra mirada sobre migración hacia Neovim+Lua, desde VSCode.
NeoVim Is Better, But Why Developers Aren't Switching To It? — perspectiva crítica sobre la adopción de Neovim.

Una introducción pragmática al uso de plugins en Neovim

sebelk — Sun, 04 May 2025 19:22:12 GMT

Ya me he referido a Neovim alguna vez en el pasado: Lo viejo, lo bueno y lo nuevo en Neovim . Se pueden extender las funcionalidades de neovim, mediante plugins, de manera similar a las de su predecesor, el editor Vim. En este artículo propongo un modo muy sencillo y lo más transparente posible para el uso de plugins en Neovim.

Hay dos tipos de plugins:

Globales: Funcionan para todo tipo de archivos.
Filetype: Sirven para un tipo particular de archivos**.

El siguiente listado muestra plugins globales que forman parte del core de neovim:

ls -l /usr/share/nvim/runtime/plugin
total 60
-rw-r--r-- 1 root root  411 mar 26 10:48 editorconfig.lua
-rw-r--r-- 1 root root 3677 mar 26 10:48 gzip.vim
-rw-r--r-- 1 root root  904 mar 26 10:48 man.lua
-rw-r--r-- 1 root root  138 mar 26 10:48 matchit.vim
-rw-r--r-- 1 root root 7966 mar 26 10:48 matchparen.vim
-rw-r--r-- 1 root root  152 mar 26 10:48 netrwPlugin.vim
-rw-r--r-- 1 root root 2160 mar 26 10:48 osc52.lua
-rw-r--r-- 1 root root 2017 mar 26 10:48 rplugin.vim
-rw-r--r-- 1 root root 1778 mar 26 10:48 shada.vim
-rw-r--r-- 1 root root  236 mar 26 10:48 spellfile.vim
-rw-r--r-- 1 root root 2527 mar 26 10:48 tarPlugin.vim
-rw-r--r-- 1 root root  442 mar 26 10:48 tohtml.lua
-rw-r--r-- 1 root root  202 mar 26 10:48 tutor.vim
-rw-r--r-- 1 root root 2642 mar 26 10:48 zipPlugin.vim

Plugin	Funcionalidad
`editorconfig`	Busca y lee archivos .editorconfig para aplicar reglas de indentación, fines de línea y codificación
`gzip`	Editar archivos comprimidos con gzip
`man`	Abrir páginas del manual en el editor
`matchit`	Extiende la funcionalidad del comando `%`
`matchparen`	Resalta paréntesis coincidentes
`netrwPlugin`	Maneja la transferencia de archivos y listado de directorios remotos a través de una red
`osc52`	Detecta si es posible usar el código de escape ANSI para copir desde vim a otras terminales para poder copiar texto desde neovim usand el clipboard del sistema
`rplugin`	Gestiona, migra, actualiza y carga remote plugins automáticamente (están escritos en otros lenguajes como Python, Ruby, Node.js, etc y que se manejan de manera independiente del editor sin afectar el rendimiento)
`shada`	Datos Compartidos entre las sesiones de neovim
`spellfile`	Descarga de archivos de ortografía
`tarPlugin`	Exploración de tarballs
`tohtml`	Conversor a html
`tutor`	Tutorial
`zipPlugin`	Exploración de archivos zip

Los scripts en vimL pueden contener comandos de edición, estructuras de control, funciones, manejo de listas, diccionarios, y puede simular objetos mediante diccionarios con referencias a funciones. El otro lenguaje nativo que incorpora neovim es Lua. Los desarrolladores de neovim consideran que ese lenguaje es más eficiente, tiene una sintaxis más moderna y estándar, maneja mejor los errores, permite que sea extendido fácilmente con plugins y módulos complejos, sin necesidad de depender de procesos externos o hacks.

Si consideramos el archivo del plugin man contiene lo siguiente:

if vim.g.loaded_man ~= nil then
  return
end
vim.g.loaded_man = true

vim.api.nvim_create_user_command('Man', function(params)
  local man = require('man')
  if params.bang then
    man.init_pager()
  else
    local err = man.open_page(params.count, params.smods, params.fargs)
    if err then
      vim.notify('man.lua: ' .. err, vim.log.levels.ERROR)
    end
  end
end, {
  bang = true,
  bar = true,
  range = true,
  addr = 'other',
  nargs = '*',
  complete = function(...)
    return require('man').man_complete(...)
  end,
})

local augroup = vim.api.nvim_create_augroup('nvim.man', {})

vim.api.nvim_create_autocmd('BufReadCmd', {
  group = augroup,
  pattern = 'man://*',
  nested = true,
  callback = function(params)
    local err = require('man').read_page(assert(params.match:match('man://(.*)')))
    if err then
      vim.notify('man.lua: ' .. err, vim.log.levels.ERROR)
    end
  end,
})

📝 Mini resumen conceptual — man.lua

✔ ¿Qué hace el plugin?

Define cómo abrir manpages usando comandos (:Man) y URIs (man://...).
Define cómo manejar errores (usa vim.notify).

✔ ¿Cómo funciona?

Previene carga múltiple con vim.g.loaded_man.
Crea un comando :Man con opciones (bang, autocompletado, etc.).
Crea un autocmd que detecta buffers con URI man:// y carga la manpage.
Usa funciones (open_page, init_pager, read_page, man_complete) definidas en el módulo man.
Muestra errores con vim.notify si algo falla.

✔ ¿Qué flujo sigue?

Usuario → :Man o :edit man:// → función del módulo man → buffer con la manpage

✅ El plugin es 100% todo Lua

Usa API moderna de Neovim:
vim.api.nvim_create_user_command
vim.api.nvim_create_autocmd
vim.notify
Usa variables globales Lua: vim.g.loaded_man
Usa funciones Lua: string.match, require, etc.

Es un plugin moderno, pensado para ser usado con Neovim o Vim con soporte de Lua.

API para plugins y herramientas

Además, neovim posee una API con la cual se pueden hacer desarrollos en otros lenguajes de programación y por eso existen plugins y/o herramientas relacionadas que no están escritos en vimL o LUA:

El plugin far.vim está desarrollado en python:

Se debe ejecutar :UpdateRemotePlugins cada vez que un plugin remoto se instale, se actualice, o se borre. Esto generará o actualizará un archivo manifest, por ejemplo:

cat ~/.local/share/nvim/rplugin.vim 
" node plugins


" python3 plugins
call remote#host#RegisterPlugin('python3', '/root/.local/share/nvim/plugged/far.vim/rplugin/python3/far', [
      \ {'sync': v:false, 'name': '_far_nvim_rpc_async_invoke', 'type': 'function', 'opts': {}},
     \ ])


" ruby plugins


" python plugins

Equivalencias entre Vim y Neovim

Abro un paréntesis para recordar las equivalencias entre archivos de Vim y Neovim:

Elemento	Vim	Neovim
Config principal	`~/.vimrc`	`~/.config/nvim/init.vim` o `init.lua`
Carpeta de configuración	`~/.vim/`	`~/.config/nvim/`
Plugins (autoload)	`~/.vim/autoload/`	`~/.local/share/nvim/site/autoload/`
Plugins (paquetes)	`~/.vim/pack/`	`~/.local/share/nvim/site/pack/`
Datos de usuario (swap, undo, backup, etc.)	Dentro de `~/.vim/` o definido por el usuario	`~/.local/state/nvim/`
Swap files	`~/.vim/swapfiles/`	`~/.local/state/nvim/swap/`
Undo files	`~/.vim/undodir/`	`~/.local/state/nvim/undo/`
Backup files	`~/.vim/backup/`	`~/.local/state/nvim/backup/`
viminfo	`~/.viminfo`	No se usa directamente
shada	No aplica (usa viminfo)	`~/.local/share/nvim/shada/main.shada`
Colorschemes	`~/.vim/colors/`	`~/.config/nvim/colors/`
After directory (sobreescribir plugins/config)	`~/.vim/after/`	`~/.config/nvim/after/`

Nota sobre shada:

Vim usa viminfo → ~/.viminfo.
Neovim usa shada → ~/.local/share/nvim/shada/main.shada.

No es recomendable hacer enlace simbólico entre estos dos archivos porque no son 100% compatibles.

Soporte nativo para plugins en Vim 8 (y en adelante)

Photo by Handy Wicaksono on Unsplash

Desde Vim 8.0 el editor cuenta con soporte nativo para paquetes. En Vim un paquete no es otra cosa que un directorio de plugins. Es decir, considerando el siguiente escenario.

El paquete lightline.vim se va a cargar automáticamente al abrir el editor, mientras que el otro plugin toggleterm podrá activarse con el comando :packadd toggleterm.nvim

Guía rápida para el método nativo de Vim 8+

Mostraré como usar 2 plugins.

1. Crear las carpetas necesarias

Abrí tu terminal y ejecutá:

mkdir -p ~/.vim/pack/misplugins/{start,opt}

Explicación rápida:

~/.vim/pack/ → carpeta donde Vim busca paquetes.
misplugins → nombre del grupo que quieras (puede ser cualquier nombre).
start/ → indica que los plugins se cargan automáticamente al abrir Vim.
opt/ → indica que los plugins se cargarán bajo demanda con el comando packadd

2. Descargar los plugins

Ahora dentro de start/, cloná los repositorios de Git de los plugins:

cd ~/.vim/pack/misplugins/opt

# vim-fugitive (permite ejecutar y gestionar comandos de Git directamente dentro de Vim, como hacer commits, ver logs, ver diferencias (diffs) y manejar ramas sin salir del editor.)
git clone https://tpope.io/vim/fugitive.git
vim -u NONE -c "helptags fugitive/doc" -c q

cd ~/.vim/pack/misplugins/start

# lightline.vim (barra de estado mejorada)
git clone https://github.com/itchyny/lightline.vim.git
# Usar el comando siguiente si lightline.vim se muestre sin colores y guardarlo en algún archivo de configuración del shell.
# export TERM=xterm-256color

Con esto ya los tenés instalados.

3. Configuración para lightline.vim|

Podés agregar algunas líneas en tu ~/.vimrc para aprovechar lightline.vim:

" Opcional: configuración mínima para lightline
set laststatus=2

4. Listo

¡Abrí Vim y ya podés usar el plugin lightline.vim!

Si querés cargar el plugin fugitive, lo hacés con:

:packadd fugitive

Importante: Los plugins escritos en lua no funcionarán en Vim

Algo interesante en Vim y Neovim es que podemos ver los plugins que ya vienen con el editor con el comando :help standard-plugin-list y con :help local-additions los plugins que vamos agregando:

O si preferimos algo más sofisticado, para ver nuestros plugins:

:echo join(keys(g:plugs), ' ')

Si bien esta funcionalidad también existe en Neovim, podemos administrar los plugins de manera más flexible y automatizada. Esto nos lleva a considerar el uso de gestores de plugins.

Gestores de plugins

Existen varios gestores de plugins:

Me parece muy recomendable vim-plug porque:

Requiere muy poca configuración: una lista con los paquetes de plugins deseados.
Instala y actualiza todos los paquetes de nuestra lista o los que seleccionemos.
Detecta y elimina plugins que borramos de nuestra lista.
Muestra el estado de los plugins.
Genera instantáneas de nuestros paquetes con su configuración, con la posibilidad de restaurarlas.
Posee atajos de teclado.
Es compatible tanto con Vim como Neovim

Si queremos deshabilitar todos los plugins podemos ejecutar nvim --noplugin.

Neovim sigue los lineamientos de la XDG Base Directory Specification. Algo que puede ser muy útil: poner el listado de plugins en un archivo separado. Esto es: creando un archivo ${XDG_CONFIG_HOME:-$HOME/.config}/nvim/plugins.vim y en el archivo ${XDG_CONFIG_HOME:-$HOME/.config}/nvim/init.vim teniendo una simple línea:

runtime plugins.vim

Entonces, comentando esa línea es una manera alternativa para desactivarlos.

Pero hay más: supongamos que tenemos esta configuración en el archivo ${XDG_CONFIG_HOME:-$HOME/.config}/nvim/plugins.vim:

Plug 'nyngwang/NeoTerm.lua'

call plug#end()

" Esta es la manera de embeber código lua en un archivo de tipo vimL
lua << EOF
require("neo-term").setup {
  exclude_filetypes = { "oil" }
}
EOF

nnoremap <F4> :NeoTermToggle<CR>
tnoremap <F4> <C-\><C-n>:NeoTermToggle<CR>
tnoremap <Esc> <C-\><C-n>:NeoTermEnterNormal<CR>

Con esta configuración:

Al presionar F4 se abirá una terminal.
Al presionar de vuelta F4 se cerrará la terminal.
Con Esc se vuelve al modo Normal en la terminal.

En tiempos en los que tanto se declama la agilidad, como contrasentido se ofrecen editores que consumen muchos recursos, con desarrollos no exentos de torpezas y caprichos impuestos de antemano. El minimalismo de Vim como de Neovim nos permite adaptarlo de acuerdo a lo que necesitemos, la posibilidad de agregar distintas funcionalidades, sea para desarrollo, mejor usabilidad y experiencia del usuario (sí: el desarrollador o sysadmin también es un usuario 😀). Finalmente, si bien tanto Vim como Neovim poseen el soporte nativo para manejar paquetes de plugins, encuentro en vim-plugin una manera mucho más conveniente de hacerlo.

Característica	Sistema Nativo (Vim 8 `packages`)	`vim-plug`
Instalación	Manual (clonar repos en `pack/`)	Automática vía script (`plug.vim`)
Configuración	En `vimrc`, usando `packadd` o estructura `start/opt`	Declarativa en `vimrc` con `Plug`
Carga diferida (lazy-loading)	Manual con `packadd` desde `opt/`	Incorporado: `on`, `for`, `cmd`, `event`
Instalación de plugins	Manual (`git clone`)	`:PlugInstall`
Actualización	Manual (`git pull` en cada plugin)	`:PlugUpdate`
Desinstalación	Manual (borrar carpeta)	`:PlugClean`
Gestión de dependencias	No soportado nativamente	Limitada (tú defines el orden)
Soporte para branches/tags	Manual (`git checkout`)	Sí (`Plug 'user/repo', { 'branch': 'dev' }`)
Paralelismo en instalación	No	Sí (instala varios plugins a la vez)
Interfaz de usuario	Ninguna	Básica pero útil (durante instalación/update)
Velocidad en carga	Muy rápida (carga solo en startup)	Muy rápida con lazy loading
Soporte oficial	Parte de Vim 8+	Mantenido por la comunidad
Curva de aprendizaje	Mayor (entender estructura `pack/`)	Muy simple y bien documentado
Compatibilidad	Solo Vim 8+	Compatible con Vim 7.4+, Neovim

Conclusión

El soporte nativo de Vim/Neovim es como una biblioteca física organizada con dos tipos de estantes:

start/: son los libros que se abren automáticamente apenas entrás a la biblioteca —es decir, los plugins que se cargan al iniciar Vim/Neovim.
opt/: son libros que están en los estantes, pero que vos tenés que buscar y abrir manualmente usando el comando :packadd.

Este sistema te da control total, pero también requiere que te ocupes de la instalación, organización y carga de cada plugin.

Los gestores de plugins, como vim-plug, funcionan como un sistema de préstamo digital moderno:

Suscripción básica: Declarás qué libros (plugins) querés en una lista de solicitudes (Plug 'autor/plugin'), y al ejecutar un comando como PlugInstall, el sistema los descarga automáticamente y los organiza en las secciones correspondientes del runtimepath.
Dependencias = citas bibliográficas que debés declarar manualmente: Si el libro A necesita al libro B para entenderse correctamente, vos tenés que pedir ambos explícitamente. A diferencia de gestores como npm, pip o cargo, no hay resolución automática de dependencias: nadie deduce relaciones por vos.
Actualizaciones periódicas: Usando el comando PlugUpdate, podés sincronizar tu colección con las últimas ediciones disponibles. Eso sí: estos comandos actualizan lo que ya tenés, pero no agregan automáticamente nuevos plugins a menos que los declares en tu configuración.

Ahora cabe preguntarse dos cosas:

¿Cómo podemos empezar a usar Lua?
Más allá de que vim-plug es una excelente opción: ¿Es actualmente la mejor para Neovim?

Más Recursos

Tutorial: Cifrar $HOME con gocryptfs

sebelk — Wed, 12 May 2021 18:11:58 GMT

En un artículo anterior: Tutorial de fscrypt para cifrar archivos, habíamos visto como cifrar archivos con fscrypt y ext4. Ahora aprenderemos otro método independiente del sistema de archivos utilizado, se trata de una herramienta llamada gocryptfs.

Conocimientos previos necesarios:

Uso habitual de línea de comandos en Linux (incluyendo entre otros manejo de propietarios y permisos)
Instalación y desinstalación de paquetes

En el ejemplo en cuestión estoy usando Debian Buster (te recomiendo primero instalarla en una máquina virtual para hacer pruebas), de modo que los pasos a seguir pueden ser un poco diferentes en otras distribuciones, pero los principios generales se mantienen. Todos los pasos hasta que lo pruebes como usuario común deben hacerse con privilegios de superusuario.

Es muy importante contar espacio suficiente para copiar temporalmente los archivos del directorio que se desea cifrar.

He cambiado el shell del usuario sergio que es dash (predeterminado en Debian) por bash, ya que el primero no está pensado para un uso interactivo habitual además de ser menos potente.

Instalar grocryptfs

apt install grocryptfs

Crear el directorio para cifrar

mkdir /home/sergio_cifrado

Inicializar el directorio

Aquí seteamos la misma contraseña que la del usuario

gocryptfs --init /home/sergio_cifrado/
Choose a password for protecting your files.
Password: 
Repeat: 

Your master key is:

    9c43faf4-16a07508-42213628-50a5c55e-
    e0c17483-c41453a0-6355f9f0-897b3aa9

If the gocryptfs.conf file becomes corrupted or you ever forget your password,
there is only one hope for recovery: The master key. Print it to a piece of
paper and store it in a drawer. This message is only printed once.

The gocryptfs filesystem has been created successfully.
You can now mount it using: gocryptfs /home/sergio_cifrado MOUNTPOINT

Montar el directorio

mkdir /home/sergio_montaje_temporario && chmod 750 /home/sergio_montaje_temporario && chown sergio. /home/sergio_temporario &&
gocryptfs /home/sergio_cifrado/ /home/sergio_temporario/
Password: 
Decrypting master key
Filesystem mounted and ready.

Ajustamos los propietarios y permisos

chown -R sergio. /home/sergio{_cifrado} && chmod 750 /home/sergio_cifrado

Copiar todos los archivos del directorio del usuario al directorio temporal

cp -Tav /home/sergio /home/sergio_temporario

Borrar el contenido del directorio del usuario (por favor realizar previamente un backup)

rm -rf /home/sergio

Desmontar el directorio cifrado

fusermount -u /home/sergio_temporario

Le cambiamos el nombre al directorio temporario por el original

mv /home/sergio_temporario /home/sergio

Todo lo que viene a continuación es necesario cuando queremos que el directorio se monte de manera automática en el momento del login.

Instalamos el módulo de PAM para montaje de volúmenes

apt install -y libpam-mount

Ejecutamos el configurador de pam

pam-auth-update

y presionamos en Aceptar.

En otras distribuciones y configuraciones, puede ser necesario editar otros archivos del directorio /etc/pam.d.

Luego hay que editar el archivo /etc/security/pam_mount.conf.xml agregando lo siguiente antes de </pam_mount>:

<volume user="sergio" fstype="fuse" options="nodev,nosuid,quiet,nonempty,allow_other"
path="/usr/bin/gocryptfs#/home/%(USER)_cifrado" mountpoint="/home/%(USER)" />

Configuramos FUSE

# /etc/fuse.conf - Configuration file for Filesystem in Userspace (FUSE)

# Set the maximum number of FUSE mounts allowed to non-root users.
# The default is 1000.
#mount_max = 1000

# Allow non-root users to specify the allow_other or allow_root mount options.
# Modificamos aquí:
user_allow_other

Eso es todo, felicitaciones si llegaste hasta aquí 😀, podemos reiniciar y probar la configuración:

Para login gráfico:

Conclusión

De esta manera pudiste configurar el cifrado automática de un directorio $HOME de un usuario. Este método es principalmente útil para equipos donde trabaja un solo usuario (podría ser tu laptop de trabajo diario por ejemplo).

Fuentes y más recursos

Tutorial de fscrypt para cifrar archivos

sebelk — Sat, 24 Apr 2021 13:30:29 GMT

Conocimientos previos necesarios:

Instalación de Linux.
Uso habitual de línea de comandos en Linux (incluyendo entre otros manejo de propietarios y permisos).
Instalación y desinstalación de paquetes.
Montaje de sistemas de archivos.

El sistema ext4 proporciona cifrado de bloques de datos y nombres de archivos. Veremos a continuación de algunas reglas generales para cifrar el directorio /home de un usuario.

¡Manos a la obra!

Los comandos precedidos por sudo indican que necesitan privilegios de root. Si querés usar sudo, sencillamente ejecutá como root:

usermod -aG sudo sergio

Obviamente aquí y en cada caso reemplazalo con tu usuario común.

Preparación del sistema de archivos

Algo que tendremos que hacer es habilitar la funcionalidad de cifrado, suponiendo que la partición de cifrado es /dev/sda1, haríamos:

sudo tune2fs -O encrypt /dev/sda1

Descarga y compilación

sudo apt update && sudo apt build-dep fscrypt

do apt -y install git && go get -d github.com/google/fscrypt/...

cd go/src/github.com/google/fscrypt/

make && sudo make install PREFIX=/usr

Configuración

Tenemos que actualizar la configuración de PAM, que servirán para desbloquear directorios al loguearse, bloquear al desloguearse, y cambiar contraseñas de acceso a los recursos cifrados.

sudo pam-auth-update

Para configurar globalmente:

sudo fscrypt setup

No se puede cifrar un directorio que ya tiene contenido, de manera que hay que crear un nuevo directorio, y luego migrar el contenido del directorio del usuario:

sudo mkdir /home/sergio_temp && sudo chown sergio.sergio /home/sergio_temp

fscrypt encrypt /home/sergio_temp

Allí podríamos elegir entre la contraseña del usuario, una passphrase o bien un archivo con clave 256-bit. En nuestro elegimos la primera opción, siempre teniendo en cuenta lo importante que es contar con una buena contraseña.

Luego chequeamos que esté todo en orden:

fscrypt status /home/sergio_temp

Ahora sí, migramos el contenido:

cp -av -T /home/sergio /home/sergio_temp

Bloqueamos el contenido del directorio

sudo fscrypt lock /home/sergio_temp --user=/home/sergio_temp

Probamos desbloquear

fscrypt unlock /home/sergio_temp

Si funciona podemos reemplazarlo por el nuevo directorio:

sudo su - mv /home/sergio{,_para-borrar}

mv /home/sergio{_temp,}

Luego al reiniciar podemos probar:

reboot

¿Cómo se ven los archivos cifrados?

Más Recursos

Tutorial de LXC

sebelk — Mon, 15 Jun 2020 00:59:38 GMT

Photo by frank mckenna on Unsplash

LXC es una herramienta extraordinaria, algo intermedio entre un chroot y una máquina virtualizada completamente. Usando el mismo kernel que el sistema anfitrión podemos tener sistemas operativos invitados en el propio filesystem. Es decir, cada SO invitado en un directorio. Pero la documentación y la interacción de los distintos componentes puede tornar algo tricky el proceso. Cansado de lidiar con documentación desperdigada por aquí y por allá decidí crear mi propio tutorial. Intentando en lo posible ser distro-agnóstico.

Aquí está:

¡Espero que lo disfruten!

Tutorial: Autenticación en SSH con clave pública

sebelk — Fri, 08 Nov 2019 12:12:36 GMT

Este es un tutorial para que empecemos a usar claves públicas para autenticarnos. El único requisito es que hayamos ingresado a un servidor o host remoto con ssh. En nuestro ejemplo ese host tiene la ip 10.0.3.11.

i
¹

El uso de autenticación por clave pública, tal como vimos en el post anterior tiene la ventaja de no tener que ingresar usuario y contraseña. Esto puede ser útil en casos en que necesitemos realizar alguna tarea en un host remoto de manera no interactiva. Por ejemplo podríamos crear una tarea programada que ejecute todos los días un script de backup. Veremos paso a paso como conseguirlo. Lo primero que tendremos que hacer es generar un par de claves. Para ellos ejecutaremos el siguiente comando: ssh-keygen

Como se ve en la imagen de abajo se nos preguntará la ruta de la clave privada, aceptamos la predeterminada presionando la tecla Enter.

y además se nos pedirá una passphrase. La passphrase es una frase que sea fácil de recordar para uno mismo, pero a la vez difícil de adivinar para otros. El propósito es cifrar la clave privada. Si te estás preguntando ¿para qué hacer todo esto si de todas maneras tendré que ingresa una passphrase para autenticarme. La respuesta es que tenemos técnicas como veremos un poco más abajo, para evitar la necesidad del ingreso de la frase una y otra vez. Ingresamos la frase una vez después de la otra:

Esto generará dos archivos en el directorio ~/.ssh: id_rsa y id_rsa.pub que son la clave privada y la clave pública respectivamente. Como sus nombres lo indican la clave privada no debe compartirse, en cambio la clave pública es la que nosirve para identificarnos como usuarios frente a otros hosts y se puede compartir.

En este momento tenemos que copiar la clave pública al host que funciona como servidor ssh. La manera más fácil y ráṕida de hacerlo es con el comando siguiente:

Ingresamos la contraseña de root y luego presionamos la tecla Enter. Lo que hace este comando es agregar la clave pública del archivo id_rsa.pub al archivo /root/.ssh/authorized_keys del servidor ssh.

Ahora lo que hacemos es reemplazar la shell actual con el agente de ssh y re-ejecutando la shell bash. El agente de ssh será el encargado de guardar las claves privadas en memoria para que no tengamos que ingresar más de una vez la passphrase:

Luego ejecutamos el comando ssh-add:

Se nos pedirá la frase, la ingresamos y le damos Enter.

A través de este tutorial mencionamos varios conceptos que podés ampliar recurriendo a los siguientes enlaces:

Photo by Jametlene Reskp on Unsplash ↩