Gestión nativa de paquetes en Vim

Tweet

28 Jun 2025

Hay muchas opciones para gestionar paquetes en Vim. Los minimalistas, disponemos de una opción nativa. En este post dejo mis notas para instalar paquetes en nuestro Vim utilizando el gestor nativo en conjunción con git.

Este post está inspirado en esta entrada de blog: Simplified Vim plugin management.

Configurar directorio para los módulos

[EXPLICAR COMO TRAERNOS ESTE DIRECTORIO DESDE GITHUB]

Según la documentación, cuando Vim inicia, después de procesar nuestro .vimrc, escanea todos los directorios dentro de packpath en busca de plugins bajo la estructura pack/*/start. En este post lo que haremos será configurar nuestro directorio de paquetes Vim a partir de un repositorio de github.

Supongamos que tenemos un repositorio en github llamado our-vim-packages (podemos usar el nombre que queramos). La primera vez que hagamos este proceso, este repositorio estará vacío. Si ya hemos usado este repo, ahí tendremos nuestros paquetes referenciados.

Lo primero será crear el directorio pack, para clonar nuestro repositorio dentro:

mkdir -p ~/.vim/pack
cd ~/.vim/pack
git clone https://github.com/nuestro-usuario/our-vim-packages.git my-packages
# en caso de no existir, creamos el directorio start:
mkdir -p my-packages/start

El nombre my-packages es arbitrario. Podemos usar cualquier otro nombre de nuestro agrado.

Con esto queda el directorio listo para empezar a poner módulos allí dentro.

Añadir un módulo

Para instalar un módulo, deberemos poner sus archivos bajo el directorio start. Por ejemplo, si queremos instalar vimtex, simplemente debemos ejecutar:

cd ~/.vim/pack/my-packages/start
git submodule add https://github.com/lervag/vimtex

En la parte final del post dejo algunos alias para poner en .bashrc para simplificar estos comandos.

Además deberíamos persitir esta acción en nuestro repositorio de git:

git add .
git commit -m 'added vimtex'
git push

Listar módulos instalados

Para ver los módulos que tenemos instalados, podemos ejecutar:

cd ~/.vim/pack/my-packages
git submodule status
# o si queremos un output más limpio:
git submodule status | awk '{print $2}'

Actualizar nuestros módulos

Para actualizar los módulos que tenemos instalados, disponemos del siguiente comando:

cd ~/.vim/pack/my-packages
git submodule update --remote --recursive

Eliminar un módulo

Si lo que queremos es eliminar un módulo, la operación es algo más compleja:

cd ~/.vim/pack/my-packages
git submodule deinit -f start/vimtex
git rm -rf --cached start/vimtex
rm -rf start/vimtex
rm -rf .git/modules/start/vimtex
git config --file .gitmodules --remove-section submodule.start/vimtex

Para persistir esta acción en github:

git add .
git commit -m 'removed vimtex'
git push

Módulos opcionales

Además del directorio ~/.vim/pack/my-packages/start, donde se alojan los módulos leídos automáticamente al iniciar Vim, también está la posibilidad de poner módulos en ~/.vim/pack/my-packages/opt. A diferencia de los módulos en start, los que están en opt no son cargados automáticamente al iniciar vim. Para cargar un módulo dentro de opt, podemos usar el comando :packadd nombremodulo.

git mv "start/vimtex" opt
sed -i "s|start/vimtex|opt/vimtex|" .gitmodules
git add .
git commit -m 'moved vimtex to opt'
git push

Aliases en .bashrc

Para facilitar la gestión de módulos Vim, podemos poner estos aliases en nuestro .bashrc:

# Esta función es para poder posicionarnos en el directorio de paquetes
goToMyVimPackages() {
    local base_dir=~/.vim/pack/my-packages
    if [ -z "$1" ]; then
        cd "$base_dir"
    else
        cd "$base_dir/$1"
    fi
}

# Instalar plugin
function _plugininstall() { 
    goToMyVimPackages start  # Navegar al directorio "start" dentro del directorio de plugins
    git submodule add $1
}

alias plugininstall="_plugininstall"

# Listar plugins
function _pluginlist() {
    goToMyVimPackages
    git submodule status | awk '{print $2}'
}
alias pluginlist="_pluginlist"

# Actualizar módulos
function _pluginupdate() {
    goToMyVimPackages
    git submodule update --remote --recursive
}
alias pluginupdate="_pluginupdate"

# Eliminar módulo
function _pluginremove(){
    goToMyVimPackages 
    git submodule deinit -f "$1"
    git rm -rf --cached "$1"
    rm -rf "$1";
    git config --file .gitmodules --remove-section submodule.$1
}

alias pluginremove='_pluginremove'

# Poner módulos en opt
function _plugindisable(){
    goToMyVimPackages
    git mv "start/$1" opt
    sed -i "s|start/$1|opt/$1|" .gitmodules
}

alias plugindisable='_plugindisable'

Para usar estos alias:

# Instalar vimtex
plugininstall https://github.com/lervag/vimtex

# Para ver nuestros módulos
pluginlist

# Para eliminar el módulo
pluginremove start/vimtex

# Para ponerlo como opcional
plugindisable vimtex

Con eso ya tenemos una base para administrar nuestros paquetes de vim sin usar un gestor. En mi caso, después de ejecutar esos comandos, añado los cambios a git para mantener actualizado mi repositorio para gestión de paquetes. Los comandos para añadir cambios a git, luego commit y push podrían ponerse en el .bashrc para que ya formen parte de los aliases. Eso ya queda en el gusto de cada uno.

Tweet