Neovim IDE: começando a transformação

Pode parecer impossível, mas acredite: você pode usar o Neovim como IDE em seus projetos, em qualquer linguagem, assim como fazemos com o VSCode.

O Neovim, por meio de um amplo conjunto de plugins gerenciados de forma centralizada, oferece funcionalidades semelhantes às principais IDEs do mercado.

Recursos como explorador de arquivos, buscador inteligente, marcador de sintaxe, temas, teclas de atalho, auto-complete, depurador e vários outros são facilmente adicionados ao editor.

Por outro lado, apesar de simples, a instalação e a configuração dos plugins responsáveis por esses recursos são um pouco mais trabalhosas quando comparadas à dos editores gráficos.

No entanto, desde que mantenha uma cópia da pasta de configuração do Neovim, você terá esse trabalho uma única vez!

Ao longo desse primeiro artigo, veremos como instalar o gerenciador de plugins (Plugin Manager) e os plugins iniciais que darão forma a nossa IDE.

Além disso, à medida que instalarmos os plugins, veremos também como utilizá-los de forma eficiente.

Mais adiante, em artigos futuros, veremos como configurar funcionalidades mais avançadas como auto-complete, debugger, linting, code actions e outras.

E o melhor: tudo isso para a(s) linguagem(ens) que você desejar!

Ao final deste conjunto de artigos teremos a nossa própria IDE, que eu particularmente gosto de chamar de Neovim IDE!

Bons estudos!

Instalação do Neovim

Antes de qualquer coisa precisamos do Neovim, é claro. Sua instalação em sistemas Linux baseados no Debian é bastante simples, porém requer atenção.

Como instalaremos mais adiante o gerenciador de plugins (lazy.nvim), precisaremos de uma versão do Neovim superior a 0.8.0.

Portanto, antes de instalar, verifique se a versão é adequada para o nosso propósito. No Ubuntu 24.04, tanto a versão do repositório apt como do snap são superiores a 0.8.0.

Dessa forma, caso utilize Ubuntu 24.04, instale sem medo! Por ser mais recente, sugiro a versão do snap:

sudo apt install neovim # v0.9.5
# ou
sudo snap install neovim # v0.11.1

Caso não saiba muito bem como trabalhar com Vim/Neovim, aconselho a leitura do artigo Comandos Vim: domine um dos editores mais famosos.

Nele, você aprenderá o mínimo para utilizar de maneira eficiente esse fantástico editor!

Considerações Iniciais

Primeiramente é importante entender um pouco do mecanismo de configuração do Neovim.

Ele permite, basicamente, que configuremos funcionalidades através de scripts Lua, Vimscript ou até mesmo combinando ambos. Esses scripts devem ficar dentro da pasta home do usuário em .config/nvim.

Atualmente recomenda-se utilizar scripts Lua, uma vez que é uma alternativa moderna e mais poderosa em relação ao Vimscript. Portanto, ele será nosso padrão aqui.

Lua é uma linguagem de programação desenvolvida pela PUC-Rio, com sintaxe simples e muito fácil de entender.

O Neovim incorpora Lua através de um arquivo chamado init.lua e interpreta esse arquivo toda vez que é inicializado.

Assim sendo, o primeiro passo para iniciarmos nossas configurações é a criação desse arquivo:

# Primeiramente a criação do(s) diret[orio(s)
mkdir -p ~/.config/nvim # Caso não tenha o diretório config

mkdir ~/.config/nvim # Senão crie apenas o diretório nvim

# Agora sim, podemos criar o init.lua:
nvim ~/.config/nvim/init.lua

Agora para testar, digite o seguinte dentro deste arquivo:

print("Olá Mundo! " .. os.date("%H:%M:%S"))

Salve e saia do editor com :wq. Em seguida, abra-o novamente e veja a barra inferior do Neovim:

Como resultado, toda vez que você abrir o Neovim essa mensagem aparecerá com a hora atualizada.

Evidentemente que isso é apenas um teste que demonstra a execução do init.lua. Portanto, apague essa linha quando quiser!

Indentação

Vamos começar a transformação do Neovim em IDE com pequenos, mas importantes ajustes que auxiliam muito na escrita de código.

Estou me referindo a indentação, fundamental em algumas linguagens como Python, por exemplo. Como o Neovim é um editor multipropósito, ele trata tabulações como texto simples.

Desta forma, precisamos convertê-las em espaços e definir quantos deles queremos que a tabulação represente visualmente no texto, no caso de arquivos que contenham TABs reais.

Além disso, temos que definir quantos espaços são adicionados ou removidos quando teclamos TAB e BACKSPACE, respectivamente.

Por fim, também precisamos informar ao Neovim como ele se comportará quando a auto-indentação for acionada.

Meio confuso, não é? Veja como são os comandos responsáveis pela indentação e suas explicações adicionais comentadas:

-- converte TABs em espaços
vim.opt.expandtab = true

-- Define quantos espaços o caractere TAB representa visualmente
-- Importante para ver corretamente arquivos que usam TABs reais (sem caractere de espaço)
vim.opt.tabstop = 4

-- Define quantos espaços o TAB ou BACKSPACE insere/remove enquanto você tecla TAB.
vim.opt.softtabstop = 4

-- Define quantos espaços adicionar/remover na indentação automática, por exemplo ao usar -- >>, <<, etc.
vim.opt.shiftwidth = 4

Adicione esse trecho ao seu init.lua e na próxima vez que abri-lo, perceba as mudanças ao teclar TAB. O valor 4 normalmente é o padrão na maioria editores.

No entanto, sinta-se à vontade para alterá-lo de acordo com seu gosto. Já vi pessoas usando o valor de apenas 2 espaços, não há nenhum problema!

Gerenciador de Plugins – Lazy.nvim

O gerenciador de plugin é uma peça fundamental que adiciona os plugins necessários para transformar o Neovim em uma IDE.

Existem vários deles disponíveis. No entanto, como precisamos escolher apenas um, optei pelo Lazy.nvim por ser o mais recomendado atualmente.

Nessa seção explicarei o suficiente para você ter o Lazy funcionando em seu editor. No entanto, caso precise de mais ajustes, ele possui ampla documentação disponível em https://lazy.folke.io/.

Instalação

Direto ao ponto, dentro da pasta ~/.config/nvim, crie os seguintes subdiretórios com o comando mkdir abaixo:

mkdir -p ~/.config/nvim/lua/config/
mkdir ~/.config/nvim/lua/plugins/

Agora, dentro da estrutura de pastas recém-criada, vamos criar o arquivo lazy.lua na pasta config:

nvim ~/.config/nvim/lua/config/lazy.lua

Dentro do arquivo aberto no Neovim, copie e cole o script que instala e configura o Lazy.nvim:

-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  local lazyrepo = "https://github.com/folke/lazy.nvim.git"
  local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
  if vim.v.shell_error ~= 0 then
    vim.api.nvim_echo({
      { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
      { out, "WarningMsg" },
      { "\nPress any key to exit..." },
    }, true, {})
    vim.fn.getchar()
    os.exit(1)
  end
end
vim.opt.rtp:prepend(lazypath)

-- Make sure to setup `mapleader` and `maplocalleader` before
-- loading lazy.nvim so that mappings are correct.
-- This is also a good place to setup other settings (vim.opt)
vim.g.mapleader = " "
vim.g.maplocalleader = "\\"

-- Setup lazy.nvim
require("lazy").setup({
  spec = {
    -- import your plugins
    { import = "plugins" },
  },
  -- Configure any other settings here. See the documentation for more details.
  -- colorscheme that will be used when installing plugins.
  install = { colorscheme = { "habamax" } },
  -- automatically check for plugin updates
  checker = { enabled = true },
})

Não se preocupe em entender exatamente como esse script funciona.

Entenda apenas que ele baixa o Lazy a partir do Github do projeto, cria um “inicializador” de atalhos com a tecla de espaço e procura por plugins no diretório ~/.config/nvim/lua/plugins.

Salve e feche o lazy.lua com :wq.

Conforme você verá mais adiante, cada plugin será representado por um arquivo .lua dentro do diretório plugins.

Como ainda não temos nenhum, o Lazy acusará erro toda vez que executarmos o Neovim. Contornamos esse problema adicionando um plugin “vazio” à lista.

Assim sendo, crie o seguinte arquivo .lua dentro da pasta plugins:

nvim ~/config/nvim/lua/plugins/vazio.lua

Em seguida, adicione isso:

return {}

Então salve e feche o vazio.lua com :wq

Por fim, adicione ao seu init.lua a seguinte linha: (abaixo das definições de indentação)

require("config.lazy")

Mais uma vez salve e feche (:wq) e, em seguida, abra o Neovim novamente.

Aparentemente nada aconteceu… no entanto, digite :Lazy e veja o resultado:

Esse é o menu do Lazy, nele você pode ver quais plugins você tem, atualizá-los, ver Logs, etc. Feio não é? Prometo que melhora bastante com a instalação de um plugin de tema!

Uma vez que faremos a instalação e a configuração dos plugins através de arquivos .lua, esse menu terá pouca utilidade nesse artigo.

No entanto, saiba que ele existe e pode ser muito útil para o gerenciamento dos seus plugins.

Configuração

O Lazy.nvim possui uma série de características que podem ser configuradas. Abordar todas elas aqui tornaria o artigo muito longo e entediante.

O arquivo de configuração do Lazy (lazy.lua) do jeito que está é o suficiente para o gerenciador funcionar de maneira satisfatória na maioria dos casos.

No entanto, se você sentir necessidade de ajustes mais profundos, o site do projeto contém todos os aspectos configuráveis muito bem explicados.

Você pode encontrar mais informações em https://lazy.folke.io/configuration.

Instalação de Plugins

O Lazy organiza seus plugins usando o que chama de “plugin specs” (especificações de plugin), que são estruturas de dados Lua que descrevem como cada plugin deve ser carregado.

Uma plugin spec nada mais é que uma tabela Lua que define:

• o repositório do plugin (normalmente autor/plugin no Github)
• condições de carregamento (prioridade de carregamento)
• dependências
• comandos que acionam o carregamento
• configurações do plugin
• etc

Portanto, sempre que quisermos instalar um novo plugin, devemos criar uma nova plugin spec e colocá-la em um arquivo .lua dentro da pasta ~/.config/nvim/lua/plugins.

Veja, por exemplo, como fica a instalação de um famoso plugin de tema chamado catppuccin:

return {
  "catppuccin/nvim", -- repositório do plugin
  lazy = false, -- condição de carregamento
  priority = 1000, -- prioridade (1000 = alta)
  name = "catppuccin", -- nome do plugin
  -- Configurações do Plugin 
  config = function()
    vim.cmd.colorscheme "catppuccin" -- nome do tema
  end,
}

Note que uma tabela Lua é uma estrutura de dados no estilo pares chave/valor, muito parecida com dicionários Python ou Maps Java.

No entanto, essa estrutura também pode assumir valores únicos, mesclando ou não com pares chave/valor. Além disso, pode conter qualquer tipo de dado, incluindo funções.

Apesar de ser interessante que você conheça Lua, penso não ser essencial que domine a linguagem.

Também acho que você não precisa se preocupar em saber tudo sobre as plugin specs do Lazy, uma vez que boa parte delas estão prontas no Github dos projetos.

Dessa maneira, basta copiar e colar o código dentro dos arquivos .lua e tudo pronto! Você verá como isso tudo funciona através dos cinco plugins que instalaremos aqui!

Caso queira ou precise de mais informações sobre specs do Lazy, você pode consultar a documentação em https://lazy.folke.io/spec

Tema – Catppuccin

A transformação do Neovim em IDE não tem graça se não aplicarmos uma camada de estilo ao nosso editor. É aqui que entra o famoso tema Catppuccin.

Então vamos praticar um pouco do conceito de plugin specs do Lazy.nvim e instalar o Catppuccin. Crie um novo arquivo (catppuccin.lua) com o comando:

nvim ./config/nvim/lua/plugins/catppuccin.lua

Em seguida cole o conteúdo abaixo:

return {
  "catppuccin/nvim", 
  lazy = false, 
  priority = 1000, 
  name = "catppuccin",
  config = function()
    -- nome do tema: catppuccin-latte, catppuccin-frappe, catppuccin-macchiato,     catppuccin-mocha
    vim.cmd.colorscheme "catppuccin-mocha" 
  end,
}

Salve e saia com o comando :wq e, logo após, entre novamente no Neovim. Veja o que acontece:

Como resultado, o Lazy nos informa que detectou um novo plugin, o instalou e carregou com sucesso. Repare que as cores mudaram, nada daquele rosa anterior.

Essa tela do Lazy aparece automaticamente toda vez que um novo plugin for detectado. Pressione a tecla q para voltar ao editor.

Assim como praticamente tudo no Neovim, o Catppuccin é altamente customizável e você pode obter mais detalhes de como fazê-lo na documentação do projeto em https://github.com/catppuccin/nvim

Eu particularmente gosto do esquema padrão, por isso deixei configurado como “catppuccin-mocha” na configuração vim.cmd.colorschema.

No entanto, você pode escolher entre outros três: catppuccin-latte, catppuccin-frappe, catppuccin-macchiato, ou até mesmo criar seu próprio esquema.

Explorador de Arquivos – Neotree

Continuando o nosso projeto Neovim IDE, precisamos de uma espécie de explorador de arquivos, algo semelhante ao que existe no VSCode.

Esse recurso facilita muito a manipulação de arquivos e diretórios, além ajudar na identificação dos tipos de arquivos através de ícones personalizados.

Portanto, seguindo nossa receita, vamos criar um novo arquivo contendo o script responsável pela instalação e configuração do Neotree:

nvim .config/nvim/lua/plugins/neotree.lua

Cole em seguida o código abaixo:

return {
  "nvim-neo-tree/neo-tree.nvim",
  branch = "v3.x",
  dependencies = {
    "nvim-lua/plenary.nvim",
    "nvim-tree/nvim-web-devicons", -- not strictly required, but recommended
    "MunifTanjim/nui.nvim",
  },
  lazy = false, -- neo-tree will lazily load itself
  opts = {
    -- Cria atalho (CTRL+N) que abre explorador no lado esquerdo
    vim.keymap.set('n', '<C-n>',':Neotree filesystem reveal left<CR>')
  },
}

Essa plugin spec, diferentemente do anterior, possui duas novas propriedades: dependencies e opts.

Dependencies contém as dependências que um plugin precisa. Nesse caso, o Neotree necessita do plenary, devicons e nui.

Nem todos os plugins precisam de dependências, dessa forma você encontrará plugin specs sem essa declaração.

Já o Opts é bastante comum nas definições de plugins e abriga sempre uma tabela Lua contendo possíveis configurações.

Neste caso, a utilizamos para criar o atalho (CTRL+n), responsável por abrir o explorador ao lado esquerdo da tela.

Agora, salve e saia e, em seguida, abra novamente o editor. Desta vez, o Lazy detectou e instalou o Neotree bem como suas dependências:

Tecle q para fechar a tela do Lazy e dessa vez, digite CTRL+n para abrir o Neotree. Em seguinda digite N (shift+n) para mostrar os arquivos ocultos:

Como resultado você será capaz de ver a estrutura de diretórios de onde executou o comando nvim. No meu caso, naveguei até a pasta plugins para mostrar nossos dois arquivos.

Digite <enter> para mostrar o conteúdo de arquivos selecionados. CTRL+n retorna ao explorador. Caso queira subir para o diretório pai, tecle BACKSPACE.

Além disso, caso queira procurar por arquivos, digite / (barra) e escreva o termo que deseja na caixa Filter.

Por fim, para criar pastas basta digitar a tecla a. Em seguida digite o nome da nova pasta na caixa de texto e finalize com <enter>.

Buscador Inteligente – Telescope

O Telescope é um dos plugins mais poderosos para o Neovim, uma vez que permite buscar, filtrar e navegar por diferentes tipos de conteúdos no seu projeto, de forma rápida e eficiente.

Vamos direto a instalação e depois concluímos com alguns exemplos para demonstrar seu funcionamento. Primeiramente vamos criar nossa spec:

nvim ~/.config/nvim/lua/plugins/telescope.lua

Com o conteúdo abaixo:

return {
    'nvim-telescope/telescope.nvim', tag = '0.1.8',
    dependencies = { 'nvim-lua/plenary.nvim' },
    config = function()
        local builtin = require('telescope.builtin')
        vim.keymap.set('n', '<leader>ff', builtin.find_files, { desc = 'Telescope find files' })
        vim.keymap.set('n', '<leader>fg', builtin.live_grep, { desc = 'Telescope live grep' })
        vim.keymap.set('n', '<leader>fb', builtin.buffers, { desc = 'Telescope buffers' })
        vim.keymap.set('n', '<leader>fh', builtin.help_tags, { desc = 'Telescope help tags' })
    end
}

Essa spec não foge muito dos conceitos já vistos anteriormente. O destaque aqui fica para a função da propriedade config, que define quatro atalhos para tipos de buscas diferentes.

Veremos como cada uma delas funciona em instantes. Antes, veja o resultado da instalação do Telescope no Lazy:

O Telescope permite procurar por:

• Arquivos nos projeto (builtin.find_files)
• Texto dentro dos arquivos (builtin.live_grep)
• Texto dentro dos buffers abertos (builtin.buffers)
• Commits do Git
• Símbolos de LSP (funções, variáveis, etc)
• Comandos recentes
• Histórico de buscas
• e várias outras coisas

Para simplificar concentrarei esforços apenas nas três primeiras, que considero as mais importantes para um ambiente de desenvolvimento.

No entanto, recomendo a leitura da documentação do projeto em https://github.com/nvim-telescope/telescope.nvim, lá você pode adicionar mais buscadores caso necessite.

Telescope Find Files

A busca de arquivos (Find Files) do Telescope é mais rápida e abrangente (Fuzzy) que consultas convencionais, como por exemplo a do Neotree.

As consultas sempre ocorrerão a partir do diretório atual, ou seja, de onde você executou o comando de abertura do Neovim (nvim).

Assim sendo, o Find Files irá procurar por arquivos dentro do diretório atual bem como seus subdiretórios, ignorando aqueles que são ocultos.

Uma vez que normalmente usamos diretórios como workspaces, a ideia é concentrar o esforço de busca somente no diretório de trabalho e seus subdiretórios.

Vamos supor que nossa pasta de trabalho seja ~/.config/nvim, justamente onde concentramos nossos arquivos lua.

Rode o Neovim a partir dela e então digite a nossa leader key <espaço> seguido de ff, conforme definido no telescope.lua:

Veja que ele mostra por padrão todos os arquivos. A medida que você digita na caixa de texto, o Telescope filtra os resultados aproximados.

Quando encontrar o que deseja, basta selecionar no arquivo e pressionar <enter> para abri-lo. Caso queira cancelar a busca, tecle <esc> duas vezes.

Telescope Live Grep

O Live Grep por sua vez procura por conteúdo dentro dos arquivos, igual ao comando grep do linux. Essa busca em específico depende de um software adicional, o ripgrep.

No entanto, como não se trata de um plugin, não podemos declará-lo como dependência no telescope.lua. Precisamos instalá-lo como um software externo:

sudo apt install ripgrep

Feito isso, abra o Neovim a partir da nossa pasta de trabalho fictícia (~/.config/nvim) e pressione espaço fg. Vamos buscar pelo termo “dependencies” para saber quais plugins possuem dependências:

Note que de maneira muito rápida, o Telescope encontrou nossas duas únicas correspondências que têm dependências declaradas: neotree.lua e telescope.lua.

Telescope Buffers

O Buffers busca arquivos registrados no histórico de sessão do Neovim. Todos os arquivos abertos ficam registrados nesse histórico.

Essa função é muito útil, principalmente em projetos grandes onde precisamos editar e consultar diversos arquivos em um curto intervalo de tempo.

Podemos acionar o Buffers com o atalho espaço fb, porém, se fizermos isso logo de cara, obviamente não teremos nada a consultar.

Dessa maneira, vamos abrir alguns arquivos através do próprio Telescope com o Find Files (espaço ff). Para essa demonstração, abrirei todos os arquivos .lua que criamos até agora.

Como resultado, ao entrar no Buffers, veja o que aparece:

A caixa Results informa que temos quatro arquivos abertos, sendo que o init.lua é o arquivo ativo. Por isso a marcação %a.

Os demais, marcados com h ou #h indicam que estão ocultos (hidden), porém, continuam no Buffer. Para visualizá-los novamente, basta selecionar um deles e pressionar <enter>.

Analisador de Sintaxe – Treesitter

Em continuidade ao nosso ainda cru Neovim IDE, adicionaremos agora um plugin capaz de “entender” a estrutura de um código de programação, em qualquer linguagem.

Isso é necessário pois queremos que o Neovim realce a sintaxe do nosso código com cores diferentes para facilitar sua visualização.

Além disso, também precisamos ter a capacidade de selecionar, mostrar e ocultar (folding) estruturas do código fonte.

Tudo isso é possível através do Treesitter, um plugin desenvolvido para oferecer funcionalidades avançadas baseadas na estrutura do código.

Dessa maneira, como de costume, vamos criar nossa spec do Treesitter conforme abaixo:

~/.config/nvim/lua/plugins/treesitter.lua

Em seguida, adicione seguinte o trecho:

return {
    "nvim-treesitter/nvim-treesitter",
    build = ":TSUpdate",
    config = function () 
        -- Ativar folding baseado no Tree-sitter
        vim.o.foldmethod = "expr"
        vim.o.foldexpr = "nvim_treesitter#foldexpr()"
        vim.o.foldenable = false  -- Não dobra automaticamente ao abrir arquivos

        local configs = require("nvim-treesitter.configs")
        configs.setup({
            ensure_installed = { "c", "lua", "javascript", "html", "java", "python" },
            sync_install = false,
            highlight = { enable = true },
            indent = { enable = true },  
            textobjects = {
              select = {
                enable = true,
                lookahead = true,
                keymaps = {
                  ["af"] = "@function.outer",  -- selecionar a função toda
                  ["if"] = "@function.inner",  -- selecionar o corpo da função
                  ["ac"] = "@class.outer", -- selecionar toda classe
                  ["ic"] = "@class.inner", -- selecionar interior da classe
                  ["aa"] = "@parameter.outer", --  selecionar parâmetro inteiro
                  ["ia"] = "@parameter.inner", -- selecionar apenas o nome do parametro
                },
              },
            },
        })
    end
}

Essa spec é um pouco mais extensa que as demais, porém não é tão complexa quanto parece. Não se preocupe em compreender tudo nela.

Reforçarei apenas alguns pontos importantes a seguir, onde você provavelmente modificará de acordo com suas necessidades.

Na spec acima, a função config determina na tabela ensure_installed que o Treesitter será capaz de “entender” códigos em C, Lua, Javascript, Html, Java e Python.

No entanto, ele não se limita a apenas essas linguagens. Na verdade ele tem uma ampla lista de linguagens suportadas, disponível em https://github.com/nvim-treesitter/nvim-treesitter?tab=readme-ov-file#available-modules

Além disso, a tabela keymaps (dentro de textobjects) cria os atalhos para selecionar estruturas, como por exemplo funções, classes, parâmetros, etc.

Após salvar, sair e entrar novamente no Neovim, O Lazy mostrará a conhecida janela de gerenciamento indicando a instalação do Treesitter:

Observação importante: o Treesitter precisa do compilador da linguagem C, portanto caso alguma mensagem de erro apareça, basta instalá-lo com sudo apt install gcc.

Por fim precisamos instalar um plugin complementar que permite a seleção semântica de trechos de código:

nvim ~/.config/nvim/lua/plugins/treesitter-textobjects.lua

{
  "nvim-treesitter/nvim-treesitter-textobjects",
  dependencies = { "nvim-treesitter/nvim-treesitter" }
}

Realce de Sintaxe

Uma das funções mais chamativas do Treesitter é o realce de sintaxe. Uma vez que é capaz de entender nosso código, ele sabe quais partes deve destacar.

Veja a diferença entre um código Python realçado (esquerda) e outro sem realce (direita):

Seleção Semântica

Já que o uso do mouse é muito limitado no Neovim (ou inexistente), precisamos de uma forma rápida de selecionar código, preferencialmente estruturas.

Como instalamos o Treesitter Text Objects e mapeamos alguns atallhos, isso não será um problema! Apesar de explicitamente documentado no arquivo Lua, deixo novamente abaixo os atalhos:

• vaf - seleciona a função toda
• vif - seleciona o corpo da função
• vac - seleciona toda classe
• vic - seleciona interior da classe
• vaa - seleciona parâmetro inteiro
• via - seleciona apenas o nome do parametro
• E várias outras funções pode ser mapeadas! https://github.com/nvim-treesitter/nvim-treesitter-textobjects

Importante reforçar que precisamos estar no modo Visual (tecla v) do Neovim para que os comandos de seleção de estrutura funcionem.

Veja por exemplo como fica o comando vif, responsável por selecionar somente o corpo de uma função. Basta deixar o cursor em qualquer lugar da função desejada e teclar vif:

Folding (Mostrar/Ocultar estruturas)

Outro recurso bastante comum em editores modernos é ocultar e mostrar blocos do código como estruturas de classes, funções, ifs, whiles, etc.

Veja no nosso código de demonstração Python como fica a função saudacao(nome) após o comando zc (ocultar sobre o cursor):

Esses são os principais comandos para ocultar e mostrar estruturas:

• za – alterna (abre/fecha) o fold atual
• zR – abre todos os folds
• zM – fecha todos os folds
• zc / zo - fecha / abre o fold sob o cursor
• :set foldlevel=99 – mostra todos os folds abertos ao abrir

Mais recursos

O Treesitter é um plugin muito rico e dispõe de muito mais recursos além dos que apresentei aqui. Mais uma vez em função da extensão do conteúdo, precisaria de um ou mais artigos somente para descrevê-lo.

Portanto, recomendo a consulta da documentação completa em https://github.com/nvim-treesitter/nvim-treesitter para adicionar ainda mais funcionalidades interessantes a sua rotina de trabalho!

Barra de Status – Lualine

Para finalizar esse já longo artigo de passos iniciais rumo a transformação do Neovim em IDE, adicionaremos um recurso bastante simples e rápido, cujo intuito é tanto cosmético quanto funcional.

Trata-se do Lualine, um plugin que modifica a barra de status do Neovim, dando uma aparência mais agradável a ela. Vamos direto ao ponto, primeiramente criando nosso famoso arquivo de spec .lua:

nvim ~.config/nvim/lua/plugins/lualine.lua

Com esse conteúdo:

return {
    'nvim-lualine/lualine.nvim',
    dependencies = { 'nvim-tree/nvim-web-devicons' },
    config = function()
        require('lualine').setup()
    end,
    opts = {
        theme = 'dracula'
    }
}

A propriedade theme, como você já deve imaginar, define um tema para a barra de status. Mais temas em https://github.com/nvim-lualine/lualine.nvim/blob/master/THEMES.md

Salve, saia e recarregue o Neovim:

A partir de agora, o Lualine modificará a barra de status do Neovim:

Conclusão

Considero as modificações que fizemos até agora como base para um editor que se aproxima de uma IDE capaz atender programadores em diversas linguagens.

Ainda faltam recursos primordiais como auto-complete, debugadores, fragmentos de código, terminal integrado, gerenciador de tarefas e mais!

Pretendo abordar estes e outros conteúdos nos próximos artigos da saga da transformação do Neovim em IDE! Não fique de fora!

Por enquanto, espero ter ajudado!

Até o próximo artigo!