Utilizando o Neovim/Vim para desenvolvimento

1. Introdução ao Neovim/Vim no Ecossistema Moderno

Em 2025, o Neovim e o Vim continuam sendo ferramentas poderosas para desenvolvedores que buscam produtividade máxima sem abrir mão da leveza. Enquanto editores como VS Code e JetBrains consomem centenas de megabytes de RAM, o Neovim opera com menos de 50 MB, oferecendo uma experiência de edição extremamente rápida e personalizável.

A principal diferença entre Vim e Neovim está na arquitetura: o Neovim foi bifurcado do Vim em 2014 para modernizar o código base, adicionando suporte nativo a Lua, uma API assíncrona e melhor integração com plugins. Para novos usuários, o Neovim é a escolha recomendada, pois combina a filosofia do Vim com recursos modernos.

Para instalar o Neovim:

Linux (Ubuntu/Debian):

sudo apt install neovim

macOS:

brew install neovim

Windows:

winget install Neovim.Neovim

Após a instalação, crie o arquivo de configuração ~/.config/nvim/init.lua (ou init.vim para Vim script). Uma configuração mínima funcional:

-- ~/.config/nvim/init.lua
vim.opt.number = true
vim.opt.relativenumber = true
vim.opt.tabstop = 4
vim.opt.shiftwidth = 4
vim.opt.expandtab = true
vim.opt.smartindent = true
vim.opt.termguicolors = true

2. Navegação e Edição Eficiente de Código

A verdadeira potência do Vim está na navegação e edição modal. Dominar movimentos avançados transforma a maneira como você interage com o código.

Movimentação avançada:
- f{char}: pula para a próxima ocorrência de {char} na linha
- t{char}: pula até antes de {char} na linha
- '': retorna ao último salto
- Ctrl+o e Ctrl+i: navega entre posições anteriores/posteriores no histórico de saltos
- ma: marca a posição atual como 'a' (use 'a para retornar)

Text objects permitem operações precisas:

ciw   - muda a palavra interna (change inner word)
ci"   - muda o conteúdo entre aspas
da(   - deleta o bloco entre parênteses incluindo os parênteses
yip   - copia o parágrafo interno (yank inner paragraph)

Gerenciamento de buffers e splits:

:split   - divide a janela horizontalmente
:vsplit  - divide verticalmente
Ctrl+w h/j/k/l - navega entre splits
:bn      - próximo buffer
:bp      - buffer anterior
:bd      - deleta buffer

Exemplo prático: Para refatorar uma função rapidamente:
1. Posicione o cursor sobre o nome da função
2. Pressione * para buscar a próxima ocorrência
3. Use cw para mudar a palavra
4. Pressione n para ir para a próxima ocorrência
5. Pressione . para repetir a última operação

3. Gerenciamento de Plugins e Configuração com Lua

O ecossistema de plugins do Neovim é vasto. O gerenciador mais moderno é o lazy.nvim, que oferece carregamento assíncrono e dependências automáticas.

Instalação do lazy.nvim:

-- Adicione no início do init.lua
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  -- Plugins essenciais
  "nvim-telescope/telescope.nvim",
  "nvim-tree/nvim-tree.lua",
  "nvim-lualine/lualine.nvim",
  "nvim-treesitter/nvim-treesitter",
})

Estrutura modular recomendada:

~/.config/nvim/
├── init.lua
├── lazy-lock.json
└── lua/
    ├── core/
    │   ├── options.lua    -- Configurações básicas
    │   ├── keymaps.lua    -- Mapeamentos de teclas
    │   └── plugins.lua    -- Lista de plugins
    └── plugins/
        ├── telescope.lua  -- Configuração do Telescope
        ├── nvim-tree.lua  -- Configuração do Nvim-tree
        └── lualine.lua    -- Configuração da Lualine

Plugins essenciais:
- Telescope: busca fuzzy de arquivos, strings, buffers e muito mais
- Nvim-tree: explorador de arquivos em árvore
- Lualine: statusline minimalista e informativa

4. LSP e Autocompletar para Produtividade

A configuração do LSP (Language Server Protocol) transforma o Neovim em um IDE completo, fornecendo autocompletar, diagnósticos, formatação e code actions.

Configuração básica do LSP:

-- plugins/lsp.lua
return {
  "neovim/nvim-lspconfig",
  dependencies = {
    "williamboman/mason.nvim",    -- Gerenciador de LSP servers
    "williamboman/mason-lspconfig.nvim",
  },
  config = function()
    require("mason").setup()
    require("mason-lspconfig").setup({
      ensure_installed = { "pyright", "tsserver", "gopls" },
    })

    local lspconfig = require("lspconfig")
    lspconfig.pyright.setup({})     -- Python
    lspconfig.tsserver.setup({})    -- JavaScript/TypeScript
    lspconfig.gopls.setup({})       -- Go
  end,
}

Autocompletar com nvim-cmp:

-- plugins/cmp.lua
return {
  "hrsh7th/nvim-cmp",
  dependencies = {
    "hrsh7th/cmp-nvim-lsp",    -- Fontes do LSP
    "hrsh7th/cmp-buffer",      -- Palavras do buffer
    "hrsh7th/cmp-path",        -- Caminhos de arquivo
    "L3MON4D3/LuaSnip",        -- Snippets
  },
  config = function()
    local cmp = require("cmp")
    cmp.setup({
      snippet = {
        expand = function(args)
          require("luasnip").lsp_expand(args.body)
        end,
      },
      mapping = cmp.mapping.preset.insert({
        ["<C-b>"] = cmp.mapping.scroll_docs(-4),
        ["<C-f>"] = cmp.mapping.scroll_docs(4),
        ["<C-Space>"] = cmp.mapping.complete(),
        ["<CR>"] = cmp.mapping.confirm({ select = true }),
      }),
      sources = cmp.config.sources({
        { name = "nvim_lsp" },
        { name = "buffer" },
        { name = "path" },
      }),
    })
  end,
}

5. Depuração e Testes Integrados

Para depuração, o nvim-dap implementa o Debug Adapter Protocol, permitindo breakpoints, inspeção de variáveis e execução passo a passo.

Configuração do DAP:

-- plugins/dap.lua
return {
  "mfussenegger/nvim-dap",
  config = function()
    local dap = require("dap")
    dap.adapters.python = {
      type = "executable",
      command = "python3",
      args = { "-m", "debugpy.adapter" },
    }
    dap.configurations.python = {
      {
        type = "python",
        request = "launch",
        name = "Launch file",
        program = "${file}",
      },
    }
  end,
}

Testes com neotest:

-- plugins/neotest.lua
return {
  "nvim-neotest/neotest",
  dependencies = {
    "nvim-neotest/neotest-python",
    "nvim-neotest/neotest-plenary",
  },
  config = function()
    require("neotest").setup({
      adapters = {
        require("neotest-python")({
          dap = { justMyCode = false },
        }),
      },
    })
  end,
}

Comandos úteis no terminal embutido:

:terminal python3 -m pytest   -- Executa testes
:terminal npm run test        -- Executa testes JavaScript
Ctrl+\ Ctrl+n                 -- Sai do modo terminal

6. Versionamento e Git no Vim

O Git é parte fundamental do workflow de desenvolvimento, e o Neovim oferece integração nativa com plugins poderosos.

Gitsigns para navegação visual:

-- plugins/gitsigns.lua
return {
  "lewis6991/gitsigns.nvim",
  config = function()
    require("gitsigns").setup({
      signs = {
        add          = { text = "│" },
        change       = { text = "│" },
        delete       = { text = "_" },
        topdelete    = { text = "‾" },
        changedelete = { text = "~" },
      },
      on_attach = function(bufnr)
        local gs = package.loaded.gitsigns
        local function map(mode, l, r, opts)
          opts = opts or {}
          opts.buffer = bufnr
          vim.keymap.set(mode, l, r, opts)
        end
        -- Navegação entre hunks
        map("n", "]c", function() gs.next_hunk() end)
        map("n", "[c", function() gs.prev_hunk() end)
        -- Stage hunk
        map("n", "<leader>hs", gs.stage_hunk)
        -- Undo stage hunk
        map("n", "<leader>hu", gs.undo_stage_hunk)
        -- Blame inline
        map("n", "<leader>hb", function() gs.blame_line() end)
      end,
    })
  end,
}

Fugitive para gerenciamento completo:

:Git status              -- Abre o status do Git
:Git diff                -- Mostra diferenças
:Git commit              -- Abre editor para mensagem de commit
:Git push                -- Envia commits para remoto
:Gbrowse                 -- Abre o arquivo no GitHub/GitLab

7. Personalização Visual e Temas

A aparência do Neovim pode ser totalmente personalizada para se adequar ao seu gosto.

Configuração de temas populares:

-- plugins/theme.lua
return {
  -- Tokyo Night
  { "folke/tokyonight.nvim", lazy = false, priority = 1000 },
  -- Catppuccin
  { "catppuccin/nvim", name = "catppuccin", lazy = false, priority = 1000 },
  -- Gruvbox
  { "ellisonleao/gruvbox.nvim", lazy = false, priority = 1000 },

  config = function()
    vim.cmd.colorscheme("tokyonight-night")
    -- Ou: vim.cmd.colorscheme("catppuccin-mocha")
    -- Ou: vim.cmd.colorscheme("gruvbox")
  end,
}

Customização de highlight groups:

-- No init.lua ou em um arquivo de configuração
vim.api.nvim_set_hl(0, "Normal", { bg = "#1e1e2e" })
vim.api.nvim_set_hl(0, "Comment", { fg = "#6c7086", italic = true })
vim.api.nvim_set_hl(0, "LineNr", { fg = "#585b70" })

Ícones com nvim-web-devicons:

-- plugins/icons.lua
return {
  "nvim-tree/nvim-web-devicons",
  config = function()
    require("nvim-web-devicons").setup({
      default = true,
    })
  end,
}

8. Workflow Avançado e Dicas Finais

Integração com tmux:
O tmux permite gerenciar múltiplas sessões de terminal. Combinado com plugins como vim-tmux-navigator, você navega entre painéis do tmux e splits do Neovim de forma transparente.

-- Mapeamentos para navegação entre tmux e Neovim
vim.keymap.set("n", "<C-h>", "<Cmd>NvimTmuxNavigateLeft<CR>")
vim.keymap.set("n", "<C-j>", "<Cmd>NvimTmuxNavigateDown<CR>")
vim.keymap.set("n", "<C-k>", "<Cmd>NvimTmuxNavigateUp<CR>")
vim.keymap.set("n", "<C-l>", "<Cmd>NvimTmuxNavigateRight<CR>")

Automação com autocommands:

-- Atualiza o LSP ao salvar arquivo
vim.api.nvim_create_autocmd("BufWritePre", {
  pattern = { "*.py", "*.js", "*.go" },
  callback = function()
    vim.lsp.buf.format()
  end,
})

-- Remove espaços em branco ao final das linhas
vim.api.nvim_create_autocmd("BufWritePre", {
  pattern = "*",
  command = [[%s/\s\+$//e]],
})

Dicas para migrar de outros editores:
1. Comece com configurações mínimas e adicione plugins gradualmente
2. Use o vimtutor (comando :Tutor no Neovim) para aprender os fundamentos
3. Mantenha um arquivo keymaps.lua documentando seus atalhos personalizados
4. Participe de comunidades como r/neovim e r/vim para dicas e suporte

O Neovim/Vim não é apenas um editor, mas uma filosofia de edição que, uma vez dominada, oferece produtividade incomparável. A curva de aprendizado inicial pode ser íngreme, mas o retorno em eficiência e satisfação é imensurável.

Referências