Forem: Sérgio Araújo

Neovim translate popup

Sérgio Araújo — Sat, 28 Feb 2026 14:08:25 +0000

Neovim Translation with translate-shell and Custom Popup

A guide to adding quick command-line translation in Neovim, with a visual popup styled like traditional translators.

Creators: opencode and Sérgio Araújo

NOTE: The current version of the proposed solution you see in this post has improved and you can find it here

Prerequisites

1. Install translate-shell

translate-shell is a command-line translator powered by Google Translate, Bing, Yandex, and more.

Direct download:

wget git.io/trans
chmod +x ./trans
sudo mv trans /usr/local/bin/

Or via git:

git clone https://github.com/soimort/translate-shell
cd translate-shell && make && sudo make install

Dependencies: gawk (4.0+) and bash or zsh (usually pre-installed on Linux).

Neovim Implementation

1. Add the translation function

In ~/.config/nvim/lua/core/utils/nvim_utils.lua, add the translate_popup function:

function M.translate_popup()
  local text = ''
  local is_multiline = false
  local mode = vim.api.nvim_get_mode().mode

  if mode == 'v' or mode == 'V' or mode == '\x16' then
    local start_pos = vim.api.nvim_buf_get_mark(0, '<')
    local end_pos = vim.api.nvim_buf_get_mark(0, '>')
    local lines = vim.api.nvim_buf_get_lines(0, start_pos[1] - 1, end_pos[1], false)
    if #lines > 1 then
      is_multiline = true
      text = table.concat(lines, '\n')
    else
      text = table.concat(lines, ' ')
    end
  else
    text = vim.fn.expand('<cword>') or ''
  end

  if text == '' then
    return
  end

  local ok, trans = pcall(function()
    local handle = io.popen('trans -b -no-ansi en:pt-BR ' .. vim.fn.shellescape(text))
    if not handle then return nil end
    local result = handle:read('*a')
    handle:close()
    return result
  end)

  if not ok or not trans or trans == '' then
    vim.notify('Failed to translate', vim.log.levels.ERROR, { title = 'Translate' })
    return
  end

  local lines = vim.split(trans:gsub('^%s+', ''):gsub('%s+$', ''), '\n')
  local filtered = {}
  for _, line in ipairs(lines) do
    table.insert(filtered, line)
  end
  if #filtered == 0 then
    vim.notify('Empty translation result', vim.log.levels.WARN, { title = 'Translate' })
    return
  end

  local width = 20
  for _, line in ipairs(filtered) do
    local line_width = vim.fn.strdisplaywidth(line)
    if line_width > width then
      width = math.min(80, line_width)
    end
  end
  local height = #filtered

  local buf = vim.api.nvim_create_buf(false, true)
  vim.api.nvim_buf_set_lines(buf, 0, -1, false, filtered)
  vim.api.nvim_buf_set_option(buf, 'filetype', 'markdown')
  vim.api.nvim_buf_set_option(buf, 'modifiable', false)

  vim.api.nvim_set_hl(0, 'TranslateBg', { bg = '#ffcc66', fg = '#000000' })
  vim.api.nvim_buf_set_extmark(buf, vim.api.nvim_create_namespace('translate'), 0, 0, {
    hl_group = 'TranslateBg',
    hl_eol = true,
    end_line = height - 1,
  })

  local row, col = unpack(vim.api.nvim_win_get_cursor(0))

  local win = vim.api.nvim_open_win(buf, true, {
    style = 'minimal',
    relative = 'cursor',
    width = width + 2,
    height = height,
    row = 1,
    col = 0,
    border = 'rounded',
    noautocmd = true,
  })

  vim.api.nvim_set_option_value('winblend', 0, { win = win })
  vim.api.nvim_set_option_value('winhighlight', 'Normal:TranslateBg', { win = win })

  vim.keymap.set('n', 'q', '<cmd>close<CR>', { buffer = buf, nowait = true })
  vim.keymap.set('n', '<Esc>', '<cmd>close<CR>', { buffer = buf, nowait = true })
end

2. Add the keymaps

NOTE: I have created a map utility to help me out creating mappings:

-- https://blog.devgenius.io/create-custom-keymaps-in-neovim-with-lua-d1167de0f2c2
-- https://oroques.dev/notes/neovim-init/
function M.map(mode, lhs, rhs, opts)
  local options = { noremap = true, silent = true }
  if opts then options = vim.tbl_extend('force', options, opts) end
  vim.keymap.set(mode, lhs, rhs, options)
end

In ~/.config/nvim/lua/core/keymaps.lua, add:

map('n', '<leader>st', nvim_utils.translate_popup, { desc = 'Show Translate (word under cursor)' })
map('x', '<leader>st', nvim_utils.translate_popup, { desc = 'Show Translate (selection)' })

3. Mnemonic

The <leader>st shortcut was chosen with the mnemonic:

s → show
t → translate

Just like other translators show ("show translate"), or simply "translate".

Features

Word under cursor: Press <leader>st with cursor on a word
Visual selection: Select text and press <leader>st to translate
Multiple lines: Selected paragraphs preserve line breaks
Default language: English → Brazilian Portuguese (en:pt-BR)
Styled popup: Orange/yellow background (#ffcc66) with black text
Close with: q or <Esc>

Demo

Credits

opencode - Implementation and development
Sérgio Araújo - Idea, testing and feedback

References

Dicas avançadas do firefox

Sérgio Araújo — Sat, 31 Jan 2026 21:01:55 +0000

O navegador firefox traz alguns recursos muito úteis, seja nativamente, seja através de algumas extensões das quais não podemos abrir mão.

Nem tudo é atalho mas...

Alguns atalhos são essenciais para o uso do firefox ou de qualquer browser, cada vez que você tira a mão do teclado perde produtividade.

Ctrl + t ............... Abrir uma nova aba
Ctrl + w ............... fechar aba atual
F5 ..................... recarregar aba atual (refresh)
Ctrl + d ............... salvar como favorito

Quando o menu de opções sumir

Muita gente fica perdida quando o menu de opções, que são os menus "Arquivo, exibir, editar some, basta pressionar a tecla Alt. E para manter o menu de opções sempre visível você vai no menu Exibir > Barra de ferramentas > Barra de Menu.

Como instalar extensões?

Você clica no ícone que se parece com uma peça de um quebra cabeças...
ou pode usar o atalho Ctrl + Shift + A para abrir o gerenciador de extensões

... E quando abrir você clica em descobrir extensões, lá você pode procurar pelo nome se não tiver o link.

Tradutor por contexto (seleção)

A extensão simple translate é utilíssima, usando a configuração postada no mega.nz ao passar o mouse sobre um conteúdo aparecerá um popup com a tradução. Você abre a configuração da extensão em extensões, clica no simple translate e nas tres bolinha opções, lá em baixo você acha a opção importar, aponte para o arquivo abaixo:

Ele está hospedado no mediafire, este é o link

clicando no link acima será exibido o código fonte da configuração mas no canto superior direito, lá na página do mega aparece uma setinha para baixar.

Você baixa, olha onde foi salvo e abre a extensão simple translate e nas opções da extensção (lá em baixo) existe uma opção importar. A minha configuração está de modo que ao passar o mouse sobre um texto em Inglês segurando o control a tradução aparece automaticamente.

Bloqueador de anúncios

A extensão Ublock Origin é fenomenal, ela irá te ajudar a bloquear quase tudo de anúncio que aparece.

Captura de tela nativa

Use o atalho Ctrl + Shift + s

Gerenciador de senhas

A extensão bitwarden além de guardar suas senhas tem um gerador de senhas fortes e pode ser habilitada para completar os campos de login dos sites, (antes crie uma conta no bitwarden). Depois que comecei a usar o bitwarden nunca mais tive dores de cabeça com senhas. Detalhe, você pode ter uma versão do bitwarden para android e cada vez que guardar uma nova senha você clica na opção para sincronizar, isso manda o banco de dados de senha atual para o servidor do bitwarden.

Para sincronizar as senhas salvas vá em configurações > opções do cofre > sincronizar agora.

Logar e sincronizar sua conta do firefox

Quando você instala o firefox ele não tem nenhuma conta associada, mas quando você loga (ou cria uma conta nova no firefox e loga) os seus favoritos e configurações meio que vão junto.

Posso então cadastrar dispositivos para os quais eu possa enviar uma aba, uso muito isso entre o laptop e o smatphone, na aba clique com o botão direito e escolha enviar para dispositivo. E quais são os dispositivos que aparecem na lista? Todos aquele em que eu logar na conta do firefox.

veja como logar na sua conta existente ou criar uma nova:

Veja como enviar favoritos para dispositivos sincronizados, em cada dispositivo você entra com sua conta firefox:

Salvar favoritos com tags

Você me perguntaria: Qual a vantagem de salvar favoritos com tags?
Digamos que eu esteja assistindo um vídeo do youtube sobre a rússia, ao salvar o favorito posso colocar as tags: russia, youtube, geopolitica.

e se eu tiver dezenas de vídeos do youtube também salvos mas que não tiverem a tag russia eles não aparecerão se eu fizer isso na barra de endereços:

+ russia geopolitica

aparecerão abaixo da barra de endereços todos os favoritos que tiverem essas duas tags. Isso é muito mais eficiente do que simplesmente salvar um favorito.

Editando as tags dos favoritos

Use o atalho ctrl + Shift + o

Veja o editor de favoritos aberto:

Criei até um script para buscar favoritos por tags, ele tem opção para copiar o arquivo places.sqlite para não ter que fechar o firefox, você pode então gerar um arquivo txt, se desejar, com todos os favoritos que contenham determinada tag. O script está no meu repositório no codeberg.

Na hora de buscar as tags direto no firefox você coloca na barra de endereços um sinal de mais seguido do nome das tags separando com espaços como na imagem abaixo:

Criar um perfil separado do firefox

No windows use a tecla windows + r

No caso do Linux abra o menu de executar e digite como na imagem acima:

firefox -p para abrir o gerenciador de perfis do firefox

Eu costumo deixar de modo que por padrão se eu digitar firefox ele não abre o meu perfil, assim, se por acaso eu deixar alguma coisa importante visível esse conteúdo não vai estar tão na cara.

Observe na imagem acima que posso ou não marcar para que o perfil selecionado se torne o perfil padrão associado ao comando único "firefox".

Depois de criar o meu perfil eu posso abrir direto nele mesmo que não seja o perfil padrão:

firefox -p sergio

DWM: Wallpaper change

Sérgio Araújo — Sun, 23 Nov 2025 13:24:08 +0000

Automatically change your wallpaper using cron

In my voidlinux I have installed:

sudo xbps-install -Sy cronie

And then I have started the service:

doas ln -s /etc/sv/crond /var/service/

NOTE: opendoas is an option for those who do not like sudo :)

My crontab:

NOTE: We need to take care of the variables, specially DISPLAY, XAUTHORITY and DBUS_SESSION_BUS_ADDRESS.

SHELL=/usr/bin/bash
PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
MAILTO=""

DISPLAY=:0
XAUTHORITY=/home/sergio/.Xauthority
DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus

# for debugging
# * * * * * /usr/bin/wal -qi "/home/sergio/img/backgrounds" >> /tmp/wal_cron.log 2>&1

# change at 5 minute interval
*/5 * * * * /usr/bin/wal -qi "/home/sergio/img/backgrounds" >/dev/null 2>&1
*/20 8-20 * * * /home/sergio/.dotfiles/bin/drink-water.sh

Drink watter reminder with cron

I have found this article teaching us how to use cron to remind us of drinking water.

in my case I have this script:

#!/usr/bin/env bash
# File: ~/.dotfiles/bin/drink-water.sh
# Last Change: Sun, Nov 2025/11/23 - 19:07:12
# Author: Sérgio Araújo
# Purpose: Notificar o usuário para se hidratar
# tags: [water, cron, dunst, notify-send]
# vim: set ts=2 sw=2 et fenc=utf-8 ft=sh nospell:

# Descobre o endereço do D-Bus da sessão atual
BUS=$(grep -z DBUS_SESSION_BUS_ADDRESS /proc/$(pgrep -u "$USER" -x dunst | head -n1)/environ | sed 's/DBUS_SESSION_BUS_ADDRESS=//')

# Você pode usar outro processo que roda na sua sessão, como:
# pgrep -u "$USER" -x sway
# pgrep -u "$USER" -x Xorg
# pgrep -u "$USER" -x xfce4-session
# pgrep -u "$USER" -x openbox
# etc.
# O dunst é ótimo porque sempre está rodando no ambiente gráfico.

export DBUS_SESSION_BUS_ADDRESS="$BUS"
export DISPLAY=:0
export XAUTHORITY="/home/sergio/.Xauthority"

notify-send -i "/home/sergio/.dotfiles/dunst/icons/drink-water.svg" \
    "Água" "$(date '+%H:%M') - Hidrate-se"

# Building a Robust Neovim Format Autocommand

Sérgio Araújo — Tue, 08 Jul 2025 21:43:47 +0000

Introduction

This article explains the process of creating an efficient and clean BufWritePre autocommand in Neovim using Lua. It walks through implementing functions to trim trailing whitespace, squeeze multiple blank lines, and format the buffer using the 'conform.nvim' plugin, while preserving the user's view (cursor position, scroll, and folds). This is intended to help Neovim users maintain clean code effortlessly on save, using a modular and reusable approach.

This work was created in partnership with ChatGPT and is based on best practices from the Neovim community.

Utility Functions in `text_manipulation.lua`

1. `trim_whitespace(bufnr)`

Removes trailing spaces at the end of each line in the given buffer. It uses the Neovim Lua API to read all lines, trims trailing whitespace with a pattern, and rewrites the lines only if modifications were made. The cursor position and view are preserved using vim.fn.winsaveview() and vim.fn.winrestview().

M.trim_whitespace = function(bufnr)
  bufnr = bufnr or 0
  if vim.bo[bufnr].modifiable == false then return end
  local view = vim.fn.winsaveview()
  local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
  local modified = false

  for i = 1, #lines do
    local trimmed = lines[i]:gsub('%s+$', '')
    if trimmed ~= lines[i] then
      lines[i] = trimmed
      modified = true
    end
  end

  if modified then
    vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
    vim.fn.winrestview(view)
  end
end

2. `squeeze_blank_lines(bufnr)`

Removes consecutive blank lines so that only one blank line remains where multiple existed. It also removes trailing blank lines at the end of the buffer. The function preserves cursor position intelligently even when blank lines are removed before it.

M.squeeze_blank_lines = function(bufnr)
  bufnr = bufnr or 0
  if vim.bo[bufnr].binary or vim.bo[bufnr].filetype == 'diff' then return end

  local cursor_line, cursor_col = unpack(vim.api.nvim_win_get_cursor(0))
  local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)

  local cleaned = {}
  local excess_blank_lines = 0
  local blank_run = 0

  for i, line in ipairs(lines) do
    local is_blank = line:match('^%s*$') ~= nil

    if is_blank then
      blank_run = blank_run + 1
    else
      if blank_run >= 2 and i <= cursor_line then
        excess_blank_lines = excess_blank_lines + (blank_run - 1)
      end
      blank_run = 0
    end

    if not is_blank or (is_blank and blank_run == 1) then
      table.insert(cleaned, is_blank and '' or line)
    end
  end

  -- Remove trailing blank lines
  for i = #cleaned, 1, -1 do
    if cleaned[i]:match('^%s*$') then
      table.remove(cleaned, i)
    else
      break
    end
  end

  with_preserved_view(function() vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, cleaned) end)

  if excess_blank_lines > 0 then
    local final_line = math.max(1, cursor_line - excess_blank_lines)
    final_line = math.min(final_line, #cleaned)
    vim.api.nvim_win_set_cursor(bufnr, { final_line, cursor_col })
  end
end

3. `with_preserved_view(op)` (from `nvim_utils.lua`)

Utility function that executes a given operation (either a Vim command string or a Lua function) while preserving the user's view—cursor position, scroll, folds, and so forth.

M.with_preserved_view = function(op)
  local view = vim.fn.winsaveview()
  local ok, err = pcall(function()
    if type(op) == 'function' then
      op()
    else
      vim.cmd(('keepjumps keeppatterns %s'):format(op))
    end
  end)
  vim.fn.winrestview(view)
  if not ok then vim.notify(err, vim.log.levels.ERROR) end
end

4. `format_all(bufnr)`

Combines the trimming of whitespace, squeezing blank lines, and formatting using the external plugin conform.nvim. If no LSP clients are attached to the buffer, it falls back to manual indentation (gg=G) while preserving the view. It also skips non-modifiable buffers, buffers with a buftype set (e.g., help, terminal), or buffers with an empty filetype.

--- Formata buffer com conform.nvim e fallback manual para reindentar via comando Vim.
--- Depende do conform e da função with_preserved_view para preservar cursor, folds etc.
--- @param bufnr number Buffer number (default 0)
M.format_all = function(bufnr)
  bufnr = bufnr or 0

  if
    not vim.api.nvim_buf_is_loaded(bufnr)
    or not vim.api.nvim_buf_get_option(bufnr, 'modifiable')
    or vim.api.nvim_buf_get_option(bufnr, 'buftype') ~= ''
    or vim.api.nvim_buf_get_option(bufnr, 'filetype') == ''
  then
    return
  end

  local conform = require('conform')
  local utils = require('core.utils')

  utils.text_manipulation.trim_whitespace(bufnr)
  utils.text_manipulation.squeeze_blank_lines(bufnr)

  local ok, err = pcall(function()
    conform.format({
      bufnr = bufnr,
      async = false,
      lsp_fallback = true,
      timeout_ms = 2000,
    })
  end)

  if not ok then
    -- fallback manual: reindenta buffer com preservação de view
    vim.api.nvim_buf_call(bufnr, function()
      M.with_preserved_view(function()
        vim.cmd('normal! gg=G')
      end)
    end)
  end
end

Autocommand Implementation

To hook this formatting flow into your Neovim workflow, create a BufWritePre autocommand that calls format_all for the buffer being saved, respecting exceptions such as quickfix or help buffers.

-- Cache augroups to avoid recreating them repeatedly
local augroups = {}
local function augroup(name)
  if not augroups[name] then
    augroups[name] = vim.api.nvim_create_augroup('sergio-lazyvim_' .. name, { clear = true })
  end
  return augroups[name]
end

local autocmd = vim.api.nvim_create_autocmd
local utils = require('core.utils')

autocmd('BufWritePre', {
  group = augroup('format_on_save'),
  buffer = 0,
  callback = function(args)
    local bufnr = args.buf

    -- Ignore buffers like quickfix, terminal, help, etc.
    local buftype = vim.api.nvim_buf_get_option(bufnr, 'buftype')
    if buftype ~= '' then return end

    utils.format_all(bufnr)
  end,
})

Explanation of `args.buf`

In the callback function, the args table contains information about the autocommand event. args.buf is the buffer number related to the event—in this case, the buffer that is about to be written. This ensures the function formats the correct buffer regardless of which buffer triggers the event.

Conclusion

This modular approach enables you to keep your code clean automatically on save, handling trimming, blank line squeezing, and formatting with fallback mechanisms. Leveraging Lua APIs directly helps maintain performance and user experience (like preserving cursor position).

This article was developed in collaboration with ChatGPT and draws from insights and best practices from the Neovim community. Your feedback and contributions are most welcome!

📌 Update: Using `conform.nvim` with a Custom Fallback

Since publishing this article, I’ve adopted conform.nvim not only for its support of external formatters and LSP, but also for the ability to inject custom logic in its fallback layer.

With a bit of Lua, I now run trim_whitespace, squeeze_blank_lines, and fallback to normal! gg=G with with_preserved_view, directly inside the lsp_fallback. This makes the separate autocommand unnecessary.

If you already have your formatting utilities, here’s how you can set it up inside your Conform plugin

-- File: ~/.config/nvim/lua/plugins/conform.lua
-- Last Change: Fri, 27 Jun 2025 - 13:24:25
-- Author: Sergio Araujo
-- vim: ts=2 sw=2 tw=78 et fenc=utf-8 ft=lua nospell:

local function fallback_format(bufnr)
    bufnr = bufnr or 0

    -- Check buffer valid state
    if not vim.api.nvim_buf_is_loaded(bufnr) then
        return
    end
    if not vim.bo[bufnr].modifiable then
        return
    end
    if vim.bo[bufnr].buftype ~= "" then
        return
    end
    if vim.bo[bufnr].readonly then
        return
    end
    if vim.bo[bufnr].filetype == "" then
        return
    end
    if vim.bo[bufnr].binary then
        return
    end

    -- Now do trimming and squeezing blank lines, etc
    local with_preserved_view = require("core.utils.nvim_utils").with_preserved_view
    local utils = require("core.utils.text_manipulation")

    utils.trim_whitespace(bufnr)
    utils.squeeze_blank_lines(bufnr)

    -- Try LSP formatting if any client attached
    local clients = vim.lsp.get_clients({ bufnr = bufnr })
    if #clients > 0 then
        vim.lsp.buf.format({ bufnr = bufnr, async = false })
    else
        -- fallback manual indent reformat
        vim.api.nvim_buf_call(bufnr, function()
            with_preserved_view(function()
                vim.cmd("normal! gg=G")
            end)
        end)
    end
end

return {
    "stevearc/conform.nvim",
    event = "BufWritePre",
    keys = {
        {
            "<leader>bf",
            function()
                require("conform").format({
                    lsp_fallback = fallback_format,
                    async = false,
                    timeout_ms = 2000,
                })
            end,
            desc = "Formatar buffer atual",
        },
    },
    config = function()
        local conform = require("conform")
        conform.setup({
            formatters_by_ft = {
                javascript = { "prettier" },
                typescript = { "prettier" },
                javascriptreact = { "prettier" },
                typescriptreact = { "prettier" },
                svelte = { "prettier" },
                css = { "prettier" },
                html = { "prettier" },
                json = { "prettier" },
                yaml = { "prettier" },
                markdown = { "prettier" },
                graphql = { "prettier" },
                lua = { "stylua" },
                python = { "isort", "black" },
                sh = { "shfmt" },
            },
            format_on_save = {
                lsp_fallback = fallback_format,
                async = false,
                timeout_ms = 2500,
            },
        })
    end,
}

I ended up combining the trim function with squeeze_blank_lines

-- Trims trailing whitespace and collapses consecutive blank lines.
-- Preserves viewport and cursor position if the buffer is visible.
-- Leaves cursor and marks untouched for hidden buffers
M.clean_buffer = function(bufnr)
  bufnr = bufnr or 0

  -- Ignora buffers não carregados, binários ou diffs
  if
    not vim.api.nvim_buf_is_loaded(bufnr)
    or vim.bo[bufnr].binary
    or vim.bo[bufnr].filetype == 'diff'
  then
    return
  end

  local is_visible = false
  local win_cursor_line, win_cursor_col

  -- Tenta preservar cursor se o buffer estiver visível em alguma janela
  for _, win in ipairs(vim.api.nvim_list_wins()) do
    if vim.api.nvim_win_get_buf(win) == bufnr then
      local cursor = vim.api.nvim_win_get_cursor(win)
      win_cursor_line, win_cursor_col = cursor[1], cursor[2]
      is_visible = true
      break
    end
  end

  local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
  local cleaned = {}
  local excess_blank_lines = 0
  local blank_run = 0

  for i, line in ipairs(lines) do
    local trimmed = line:gsub('%s+$', '')
    local is_blank = trimmed:match('^%s*$') ~= nil

    if is_blank then
      blank_run = blank_run + 1
    else
      if blank_run >= 2 and is_visible and win_cursor_line and i <= win_cursor_line then
        excess_blank_lines = excess_blank_lines + (blank_run - 1)
      end
      blank_run = 0
    end

    if not is_blank or blank_run == 1 then table.insert(cleaned, is_blank and '' or trimmed) end
  end

  -- Remove excesso de linhas em branco no final, mantendo no máximo uma (se já existir)
  local last = #cleaned
  local blank_count = 0

  for i = last, 1, -1 do
    if cleaned[i]:match('^%s*$') then
      blank_count = blank_count + 1
      if blank_count >= 2 then table.remove(cleaned, i) end
    else
      break
    end
  end

  -- Aplica alterações com preservação de view se possível
  local function apply_changes() vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, cleaned) end

  if is_visible then
    local view = vim.fn.winsaveview()
    apply_changes()
    vim.fn.winrestview(view)
  else
    apply_changes()
  end

  -- Restaura cursor apenas se o buffer visível continua na janela ativa
  if is_visible and win_cursor_line and win_cursor_col then
    local final_line = math.max(1, win_cursor_line - excess_blank_lines)
    final_line = math.min(final_line, #cleaned)
    if vim.api.nvim_win_is_valid(0) and vim.api.nvim_win_get_buf(0) == bufnr then
      vim.api.nvim_win_set_cursor(0, { final_line, win_cursor_col })
    end
  end
end

You also use the unified function in your code.

With this configuration, you retain all the power of Conform, and gain precise control over what happens when external formatters or LSP aren’t available.

Thanks again to the awesome Neovim community and to ChatGPT for helping refine this solution.

My nvim repo is here

New update:

I ended up noticing that the LSP does not sends any error when it does not have a server attached, as a result the fallback does not run. So I decided to swich to none-ls:

-- File: ~/.config/nvim/lua/plugins/none-ls.lua
-- Last Change: Sun, Jul 2025/07/20
-- Author: Sergio Araujo

return {
  'nvimtools/none-ls.nvim',
  enabled = true,
  event = { 'BufReadPre', 'BufNewFile' },
  dependencies = { 'nvim-lua/plenary.nvim' },
  keys = {
    {
      '<leader>bf',
      function()
        local bufnr = vim.api.nvim_get_current_buf()
        require('core.utils.format_fallback').run(bufnr)
      end,
      desc = 'Formatar buffer atual (fallback + LSP)',
    },
  },
  config = function()
    local null_ls = require('null-ls')
    local formatting = null_ls.builtins.formatting

    local augroup = vim.api.nvim_create_augroup('AutoFormatGroup', { clear = true })

    null_ls.setup({
      sources = {
        formatting.stylua,
        formatting.prettierd,
        formatting.black,
        formatting.isort,
        formatting.shfmt,
      },
    })

    -- Autocomando sempre registrado, mesmo sem cliente LSP
    vim.api.nvim_create_autocmd('BufWritePre', {
      group = augroup,
      callback = function(args)
        local bufnr = args.buf
        require('core.utils.format_fallback').run(bufnr)
      end,
    })
  end,
}
-- vim: set ts=2 sw=2 tw=78 et fenc=utf-8 ft=lua nospell:

The module used in none-ls

-- File: ~/.config/nvim/lua/core/utils/format_fallback.lua
-- Last Change: Sun, Jul 2025/07/20 - 07:35:52
-- Author: Sergio Araujo

local M = {}

function M.run(bufnr)
  bufnr = bufnr or 0
  local api = vim.api

  -- Validações básicas do buffer
  if not api.nvim_buf_is_loaded(bufnr) then return end
  if not api.nvim_buf_get_option(bufnr, 'modifiable') then return end
  if api.nvim_buf_get_option(bufnr, 'buftype') ~= '' then return end
  if api.nvim_buf_get_option(bufnr, 'readonly') then return end
  if api.nvim_buf_get_option(bufnr, 'filetype') == '' then return end
  if api.nvim_buf_get_option(bufnr, 'binary') then return end

  local with_preserved_view = require('core.utils.nvim_utils').with_preserved_view
  local utils = require('core.utils.text_manipulation')

  -- 1. Limpeza: trim whitespace + squeeze blank lines
  utils.clean_buffer(bufnr)

  -- 2. Formatação clássica: indentação gg=G
  vim.api.nvim_buf_call(bufnr, function()
    with_preserved_view(function() vim.cmd('normal! gg=G') end)
  end)

  -- 3. Formatação via LSP se cliente anexado
  local clients = vim.lsp.get_active_clients({ bufnr = bufnr })
  if #clients > 0 then
    pcall(function() vim.lsp.buf.format({ bufnr = bufnr, async = false }) end)
  end
end

return M
-- vim: set ts=2 sw=2 tw=78 et fenc=utf-8 ft=lua nospell:

nvim: Telescope toggle cwd

Sérgio Araújo — Mon, 23 Jun 2025 16:54:08 +0000

Intro

Being abble to change the scope of a search, grep or other commands gives us more control.

Finding the root dir

--- Returns project_root
--- @param bufnr number|nil Buffer
--- @return string root dir
M.root = function(bufnr)
  bufnr = bufnr or 0
  local markers = {
    '.git',
    '.hg',
    '.svn',
    'pyproject.toml',
    'setup.py',
    'requirements.txt',
    'package.json',
    'tsconfig.json',
    'Makefile',
    'CMakeLists.txt',
    '.nvim-root',
  }

  return vim.fs.root(bufnr, markers) or vim.fn.getcwd()
end

Custom telescope find_files

This module will be called via keymap

-- File: ~/.config/nvim/lua/core/utils/telescope.lua
-- Last Change: 2025-06-23
-- Author: Sergio Araujo

local M = {}

local actions = require('telescope.actions')
local pickers = require('telescope.pickers')
local finders = require('telescope.finders')
local conf = require('telescope.config').values
local ts_utils = require('telescope.utils')
local builtin = require('telescope.builtin')
local utils = require('telescope.utils')

local get_root = require('core.utils.file_system').root

-- Função para path_display que remove prefixo Termux e mantém estilo tail+path
local function oldfiles_path_display(_, path)
  local termux_prefix = '/data/data/com.termux/files/home/'
  if path:sub(1, #termux_prefix) == termux_prefix then path = path:sub(#termux_prefix + 1) end

  local tail = utils.path_tail(path)
  local display = string.format('%s %s', tail, path)
  local hl_start = #tail + 1
  local hl_end = #display

  return display, { { { hl_start, hl_end }, 'Comment' } }
end

-- Garante um diretório válido mesmo que buffer esteja vazio
local function get_valid_buf_dir()
  local dir = ts_utils.buffer_dir()
  return (dir and dir ~= '') and dir or vim.loop.cwd()
end

-- Find files com toggle de cwd
M.find_files_with_toggle = function()
  local root = get_root()
  if not root or root == '' then
    vim.notify('Root dir não encontrado. Você está fora de um projeto?', vim.log.levels.WARN, {
      title = 'Find Files',
    })
    return
  end

  local buf_dir = get_valid_buf_dir()
  local current_cwd = root

  local function picker()
    builtin.find_files({
      cwd = current_cwd,
      attach_mappings = function(prompt_bufnr, map)
        map('i', '<a-d>', function()
          actions.close(prompt_bufnr)
          local new_cwd = (current_cwd == root) and buf_dir or root
          local title = 'Find Files'

          if new_cwd ~= current_cwd then
            current_cwd = new_cwd
            vim.notify('cwd switched to: ' .. current_cwd, vim.log.levels.INFO, { title = title })
          else
            vim.notify('cwd não foi alterado (já em ' .. current_cwd .. ')', vim.log.levels.WARN, { title = title })
          end

          picker()
        end)
        return true
      end,
    })
  end

  picker()
end

-- Grep customizado com toggle de cwd e preservação do prompt
M.custom_grep_with_toggle = function()
  local root = get_root()
  if not root or root == '' then
    vim.notify('Root dir não encontrado. Você está fora de um projeto?', vim.log.levels.WARN, {
      title = 'Custom Grep',
    })
    return
  end

  local buf_dir = get_valid_buf_dir()
  local current_cwd = root
  local current_prompt = ''

  local function picker()
    pickers
      .new({}, {
        prompt_title = 'Custom Grep',
        finder = finders.new_job(function(prompt)
          if prompt == '' then return nil end
          current_prompt = prompt
          return { 'rg', '--vimgrep', '--no-heading', prompt }
        end, nil, { cwd = current_cwd }),
        previewer = conf.grep_previewer({}),
        sorter = conf.generic_sorter({}),
        default_text = current_prompt,
        attach_mappings = function(prompt_bufnr, map)
          map('i', '<a-d>', function()
            actions.close(prompt_bufnr)
            local new_cwd = (current_cwd == root) and buf_dir or root
            local title = 'Custom Grep'

            if new_cwd ~= current_cwd then
              current_cwd = new_cwd
              vim.notify('cwd switched to: ' .. current_cwd, vim.log.levels.INFO, { title = title })
            else
              vim.notify('cwd não foi alterado (já em ' .. current_cwd .. ')', vim.log.levels.WARN, { title = title })
            end

            picker()
          end)
          return true
        end,
      })
      :find()
  end

  picker()
end

-- Oldfiles com path_display customizado para Termux
M.oldfiles_clean = function()
  builtin.oldfiles({
    path_display = oldfiles_path_display,
    layout_strategy = 'vertical', -- ou "horizontal", conforme preferir
    layout_config = {
      height = 0.5, -- aqui você diminui a altura (0.3 = 30% da tela)
      width = 0.7, -- opcional: ajustar largura também
      prompt_position = 'top',
      preview_cutoff = 1, -- para esconder preview em telas pequenas
    },
  })
end

return M

The keymaps

In your telescope keys table place

-- Adjust the module path to reflect you realitty
{
      '<leader>ff',
      function() require('core.utils.telescope').find_files_with_toggle() end,
      desc = 'Find Files (toggle raiz/buffer com Alt+D)',
},
{
      '<leader>fg',
      function() require('core.utils.telescope').custom_grep_with_toggle() end,
      desc = 'Custom Grep (rg) toggle root/buffer com <A-d>',
},

neovim: Wrap selection into clipboard

Sérgio Araújo — Mon, 16 Jun 2025 19:40:06 +0000

Intro

NOTE: The proposed solutions here have evolved a little bit, my utils.lua was modularized becomming a folder. If you want to see the differences follow this link.

Sharing code using markdown is way common these days. What about having those backticks and the language of the code (our fenced code) wrapped around the selection and placed into the clipboard at the distance of a keyboard map?

First we define a lua function to get the visual selection

get_clipboard_selection

--- @return string # selected text
M.get_visual_selection = function()
  local mode = vim.fn.mode()
  if not vim.tbl_contains({ 'v', 'V', '\22' }, mode) then return '' end

  -- visual selection margins
  local s_pos = vim.fn.getpos('v')
  local e_pos = vim.fn.getpos('.') -- cursor atual

  local s_row, s_col = s_pos[2], s_pos[3]
  local e_row, e_col = e_pos[2], e_pos[3]

  -- if selection is backwards
  if s_row > e_row or (s_row == e_row and s_col > e_col) then
    s_row, e_row = e_row, s_row
    s_col, e_col = e_col, s_col
  end

  local lines = vim.api.nvim_buf_get_lines(0, s_row - 1, e_row, false)
  if #lines == 0 then return '' end

  lines[1] = string.sub(lines[1], s_col)
  if #lines == 1 then
    lines[1] = string.sub(lines[1], 1, e_col - s_col + 1)
  else
    lines[#lines] = string.sub(lines[#lines], 1, e_col)
  end

  return table.concat(lines, '\n')
end

Wrap visual selected text with fenced code

Now a helper wrapper function that adds backtics and the language name around the selected text

function M.wrap_in_markdown_codeblock(text, lang)
  if not text or text == '' then return '' end
  lang = lang or ''
  return string.format('```%s\n%s\n```', lang, text)
end

The keymap

The functions of sections above are in text_manipulation.lua module.

local text_utils = require('core.utils.text_manipulation')

map('v', '<M-s>', function()
  local wrap_in_markdown_codeblock = text_utils.wrap_in_markdown_codeblock
  local ft = vim.bo.filetype
  local text = text_utils.get_visual_selection()

  if text == '' then
    vim.notify('No selection found', vim.log.levels.WARN)
    return
  end

  local wrapped = wrap_in_markdown_codeblock(text, ft)
  vim.fn.setreg('+', wrapped)
  vim.notify('markdown block copied into reg +', vim.log.levels.INFO)
end, { desc = 'Copy selection as markdown fenced code' })

Neovim toggle moody words

Sérgio Araújo — Sat, 14 Jun 2025 11:03:37 +0000

Toggling values in programming is highlly frequent. What about a lua function and a mapping for that?


local M = {}

M.switch_moody_word = function()
  -- Grupos de estados relacionados (ordem importa)
  local state_groups = {
    { 'true', 'false' },
    { 'on', 'off' },
    { 'in', 'out' },
    { 'start', 'stop' },
    { 'show', 'hide' },
    { 'enable', 'disable' },
    { 'yes', 'no' },
    { 'up', 'down' },
    { 'always', 'never' },
    { 'error', 'warn', 'info', 'debug', 'trace' },
    { 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday' },
  }

  -- Ajusta capitalização para combinar com a palavra original
  local function match_case(original, new)
    if original:match('^%u+$') then return new:upper() end -- TODO → DEBUG
    if original:match('^%l+$') then return new:lower() end -- todo → debug
    if original:match('^%u%l+$') then return new:sub(1, 1):upper() .. new:sub(2):lower() end -- Todo → Debug
    return new
  end

  -- Pega a próxima palavra dentro do mesmo grupo
  local function get_next_word(word)
    local lower = word:lower()
    for _, group in ipairs(state_groups) do
      for i, w in ipairs(group) do
        if w == lower then
          local next = group[(i % #group) + 1]
          return match_case(word, next)
        end
      end
    end
    return nil
  end

  -- Palavra sob o cursor
  local word = vim.fn.expand('<cword>')
  local replacement = get_next_word(word)
  if not replacement then return end

  -- Substitui palavra no buffer manualmente (evita bugs com `ciw`)
  local _, col = unpack(vim.api.nvim_win_get_cursor(0))
  local line = vim.api.nvim_get_current_line()

  local start_col = col
  while start_col > 0 and line:sub(start_col, start_col):match('[%w_]') do
    start_col = start_col - 1
  end
  start_col = start_col + 1

  local end_col = col + 1
  while line:sub(end_col, end_col):match('[%w_]') do
    end_col = end_col + 1
  end
  end_col = end_col - 1

  local new_line = line:sub(1, start_col - 1) .. replacement .. line:sub(end_col + 1)
  vim.api.nvim_set_current_line(new_line)
end

return M

Now an intuitive mapping to toggle these words from our list above

local switch_moody_word = require('utils').swich_moody_word

-- NOTE: Adjust the require to fit your environment realitty

vim.keymap.set('n', '<Tab>', function() switch_moody_word() end, {
  desc = ' [T]oggle [b]oolean',
  silent = false,
})

neovim: clipboard magic

Sérgio Araújo — Wed, 04 Jun 2025 11:01:05 +0000

Intro

In this article I will share some of my daily life solutions to make my neovim workflow smoother.

Since posting this article my repository was updated with more elaborate code. here

If I want copy a text and open in neovim (zsh)

I do ...

# Edit content of clipboard on vim
function _edit_clipboard(){
  # pbpaste | nvim
  termux-clipboard-get | nvim -c 'setlocal bt=nofile bh=wipe nobl noswapfile nu'
}
zle -N edit-clipboard _edit_clipboard
bindkey '^x^v' edit-clipboard

I also have an autoloaded "nvimscratch" do deal with arguments and pipes:

nvscratch() {
  local content

  if [[ -p /dev/stdin ]]; then
    content=$(cat -)  # reads from pipes
  else
    content="$("$@")"  # runs with arguments
fi
## now we open the content in a scratch buffer
nvim -c "enew | setlocal buftype=nofile bufhidden=wipe noswapfile" +"0read !echo \"$content\""
}

In termux my pbpaste and pbcopy come from

# for zsh
(( $+commands[termux-clipboard-get] )) && {
  alias pbpaste='termux-clipboard-get'
  alias pbcopy='termux-clipboard-set'
}

in regular linux use xclip instead of termux-clipboatd. Then I cand run

some_command | pbcopy

pbpaste | nvscratch

Blockwise mode made easy

We frequently see articles and videos about visual block mode but sometines
people forget about pressing ctrl-v, and I have found a perfect solution for this:

NOTE: I usually cite the sources but in this case I have to say sorrow,
but the code bellow will make every insert "I", "A", and "gI", become
blockwise. (see my map function bellow)

-- Better block-wise operations on selected area
local blockwise_force = function(key)
    local c_v = vim.api.nvim_replace_termcodes('<C-v>', true, false, true)
    local keyseq = {
        I = { v = '<C-v>I', V = '<C-v>^o^I', [c_v] = 'I' },
        A = { v = '<C-v>A', V = '<C-v>0o$A', [c_v] = 'A' },
        gI = { v = '<C-v>0I', V = '<C-v>0o$I', [c_v] = '0I' },
    }
    return function() return keyseq[key][vim.fn.mode()] end
end
map('x', 'I', blockwise_force('I'), { expr = true, noremap = true, desc = 'Blockwise Insert' })
map('x', 'gI', blockwise_force('gI'), { expr = true, noremap = true, desc = 'Blockwise Insert' })
map('x', 'A', blockwise_force('A'), { expr = true, noremap = true, desc = 'Blockwise Append' })

In my utils.lua I have a map function just to make easy creating new mappings (you can use vim.keymap.set instead):

NOTE: For newbies. We have a convetion: lua modules start with local M = {} and we finish them with return M. In the code below I am just showing some functions. Those who start whit M. are inside a module.

-- https://blog.devgenius.io/create-custom-keymaps-in-neovim-with-lua-d1167de0f2c2
-- https://oroques.dev/notes/neovim-init/
M.map = function(mode, lhs, rhs, opts)
    local options = { noremap = true, silent = true }
    if opts then options = vim.tbl_extend('force', options, opts) end
    vim.keymap.set(mode, lhs, rhs, options)
end

Paste the clipboard right away blockwise:

It was been a while I needed this solution, because I am using nvim in termux and the 'termux-clipboard (get and set)' does not allows me to convert the clipboard to blockwise, linewise or characterewise. The idea is:

Using an internal vim register to receive the clipboard content, make it blockwise, paste at cursor position and restore the temporary register content, because in somewere else the temporary register I am using for this process could mess things up.

So, first we creare a function to use a temporary register and run a callback function we will use in our mapping:

-- paste into your utils.lua (as an example)

M.with_temp_register = function(reg, callback)
    local content = vim.fn.getreg(reg)
    local regtype = vim.fn.getreginfo(reg).regtype

    callback()

    vim.fn.setreg(reg, content, regtype)
end

Now we are going to use our function in a Alt-2 mapping (just because I have a huge amount of mappings)

local UTILS = require('core.utils')

map("n", "<M-2>", function()
    ---@type string
    local reg_clip_raw = vim.fn.getreg('+')

    ---@type string[]
    local reg_clip = vim.split(reg_clip_raw, "\n", { plain = true })

    UTILS.with_temp_register("z", function()
        vim.fn.setreg("z", reg_clip, "b")
        vim.cmd('normal! "zp')
    end)

    print("Clipboard colado como blockwise")
end, { desc = "Colar clipboard como blockwise" })

Using only lua api to paste @+ blockwise:

M.paste_blockwise = function(lines)
  local row, col = unpack(vim.api.nvim_win_get_cursor(0))
  row = row - 1

  local buf = 0
  local existing_lines = vim.api.nvim_buf_get_lines(buf, row, row + #lines, false)

  for i, l in ipairs(lines) do
    local target = existing_lines[i] or ""
    if #target < col then
      target = target .. string.rep(" ", col - #target)
    end
    existing_lines[i] = target:sub(1, col) .. l .. target:sub(col + 1)
  end

  vim.api.nvim_buf_set_lines(buf, row, row + #lines, false, existing_lines)
end

The keymap

-- Uso:
map("n", "<M-4>", function()
  local block = vim.split(vim.fn.getreg("+"), "\n", { plain = true })
  UTILS.paste_blockwise(block)
  print("Colado como bloco via API")
end)

Final note: Probably I am going to add more content in this article. Please give us you opinion we appreciate it very much!

Nvim: Persistent colorscheme choice

Sérgio Araújo — Wed, 14 May 2025 17:12:49 +0000

In general we arecused to set our colorscheme in a options file where we write our choice, but nativelly there is not a dinamic system to allow us change our colirscheme.

Just some steps

First create a theme.json in your nvim folder

~/.config/nvim/theme.json where we will save the color. In my case the file looks like:

{"colorscheme":"onedark"}

in your init.lua require a file require('core.theme') with this content:

-- ~/.config/nvim/lua/core/theme.lua

local theme_file = vim.fn.stdpath('config') .. '/theme.json'
local colorscheme = 'habamax' -- fallback

-- Tenta ler o arquivo theme.json
local function load_colorscheme()
  local ok, json = pcall(vim.fn.readfile, theme_file)
  if ok and json and #json > 0 then
    local decoded = vim.fn.json_decode(table.concat(json, '\n'))
    if decoded and decoded.colorscheme then
      return decoded.colorscheme
    end
  end
  return colorscheme
end

vim.defer_fn(function()
  local cs = load_colorscheme()
  local ok = pcall(vim.cmd.colorscheme, cs)
  if not ok then
    vim.notify('Colorscheme ' .. cs .. ' not found! Using fallback.', vim.log.levels.WARN)
    pcall(vim.cmd.colorscheme, colorscheme)
  end
end, 10)

Now an autocommand to detect when you choose a new theme:

vim.api.nvim_create_autocmd('ColorScheme', {
  group = vim.api.nvim_create_augroup('SaveColorscheme', { clear = true }),
  callback = function(args)
    local theme = args.match
    if theme == 'habamax' then return end -- evita salvar fallback
    local path = vim.fn.stdpath('config') .. '/theme.json'
    local ok, f = pcall(io.open, path, 'w')
    if ok and f then
      f:write(vim.json.encode({ colorscheme = theme }))
      f:close()
    end
  end,
})

You can setup your telescope pickers.colorscheme with:

Note: Once we have an outcommand you can ignore the code below but if you want to learn how do it via telescope...

colorscheme = {
          enable_preview = true,
          previewer = false,
          layout_config = {
            height = 0.4,
            width = 0.5,
          },
          attach_mappings = function(_, map)
            local actions = require('telescope.actions')
            local action_state = require('telescope.actions.state')

            map('i', '<CR>', function(prompt_bufnr)
              local selection = action_state.get_selected_entry()
              local theme = selection.value
              actions.close(prompt_bufnr)
              vim.cmd.colorscheme(theme)

              -- salva o tema no theme.json
              local path = vim.fn.stdpath('config') .. '/theme.json'
              local ok, file = pcall(io.open, path, 'w')
              if ok and file then
                file:write(vim.fn.json_encode({ colorscheme = theme }))
                file:close()
                vim.notify('Tema salvo: ' .. theme, vim.log.levels.INFO)
              else
                vim.notify('Erro ao salvar o tema!', vim.log.levels.ERROR)
              end
            end)

            return true
          end,
        },

and let your choice be saved automatically

nvim

Sérgio Araújo — Mon, 21 Apr 2025 21:30:43 +0000

Another great neovim smooth scroll plugin

Sérgio Araújo — Wed, 17 Jul 2024 16:16:58 +0000

The missing smooth scroll

As far as I know neovim does not have a decent scroll feaure, the jumps are so fast you can become confused.

I have being using neoscroll for a while, but now I am using cinnamon:

-- File: ~/.config/nvim/lua/plugins/cinnamon.lua
-- Last Change: Wed, Jul 2024/07/17 - 08:38:44
-- Author: Sergio Araujo-- 
--
-- This plugin is for animated scrolling

return {
  "declancm/cinnamon.nvim",
  version = "*", -- use latest release
  opts = {
    -- change default options here
    -- Enable all provided keymaps
    keymaps = {
      basic = true,
      extra = true,
    },
    -- Custom scroll options
    options = {
      mode = "cursor",  -- Animate cursor and window scrolling for any movement
      delay = 5,        -- Delay between each movement step (in ms)
      step_size = {
        vertical = 1,   -- Number of cursor/window lines moved per step
        horizontal = 2, -- Number of cursor/window columns moved per step
      },
      max_delta = {
        line = false,   -- Maximum distance for line movements before scroll animation is skipped
        column = false, -- Maximum distance for column movements before scroll animation is skipped
        time = 1000,    -- Maximum duration for a movement (in ms)
      },
      -- Optional post-movement callback
      callback = function()
        -- print("Scrolling done!")
      end,
    },

  },
  keys = {
    { '<c-d>', '<cmd>lua require("cinnamon").scroll("<C-d>zz")<cr>', mode = 'n', },
    { '<c-u>', '<cmd>lua require("cinnamon").scroll("<C-u>zz")<cr>', mode = 'n', },
    { '<c-f>', '<cmd>lua require("cinnamon").scroll("<C-f>zz")<cr>', mode = 'n', },
    { '<c-b>', '<cmd>lua require("cinnamon").scroll("<C-b>zz")<cr>', mode = 'n', },
    { 'zz',    '<cmd>lua require("cinnamon").scroll("zz")<cr>',      mode = 'n', },
    { 'zt',    '<cmd>lua require("cinnamon").scroll("zt")<cr>',      mode = 'n', },
    { 'zb',    '<cmd>lua require("cinnamon").scroll("zb")<cr>',      mode = 'n', },
    { 'gg',    '<cmd>lua require("cinnamon").scroll("gg")<cr>',      mode = 'n', },
    { 'G',    '<cmd>lua require("cinnamon").scroll("G")<cr>',      mode = 'n', },
  }
}

Please give us your feedback

My personal detox command

Sérgio Araújo — Fri, 28 Jun 2024 15:52:02 +0000

The original detox

It is perfect but in termux i do not have it in my repositories, so:

#!/bin/bash
#
# Script: dtx
# Description: Rename files by removing special characters and normalizing names.
#
# Usage: dtx [-d] [-h] files...
# Options:
#   -d    Dry run. Show the final result without renaming.
#   -h    Show this help message.
#
# Dependencies: Requires Python 3 and the 'unidecode' module. Install with:
#   pip install unidecode
#

# Get the script name dynamically
script_name=$(basename "${BASH_SOURCE[0]}")

show_help() {
  echo "Usage: $script_name [-d] [-h] files..."
  echo "Rename files by removing special characters and normalizing names."
  echo
  echo "Options:"
  echo "  -d    Dry run. Show the final result without renaming."
  echo "  -h    Show this help message."
}

check_unidecode() {
  python3 -c 'import unidecode' >/dev/null 2>&1
  if [ $? -ne 0 ]; then
    echo "Error: Python module 'unidecode' not found."
    echo "Please install it using:"
    echo "    pip install unidecode"
    exit 1
  fi
}

dry_run=false

# Check if unidecode module is available
check_unidecode

# Parse options
while getopts "dh" opt; do
  case ${opt} in
    d )
      dry_run=true
      ;;
    h )
      show_help
      exit 0
      ;;
    \? )
      show_help
      exit 1
      ;;
  esac
done
shift $((OPTIND -1))

if [ "$#" -lt 1 ]; then
  show_help
  exit 1
fi

for file in "$@"; do
  if [ -d "$file" ]; then
    # Transliterate UTF-8 characters to ASCII using Python unidecode for directories
    new_filename=$(echo "$file" | python3 -c 'import sys, unicodedata; filename = sys.stdin.read().strip(); filename = unicodedata.normalize("NFD", filename).encode("ascii", "ignore").decode("ascii").replace(" ", "-").replace("_", "-").replace("/", "-").replace(".", "-"); filename = "-".join(filter(None, filename.split("-"))); print(filename)')

    # Check if the directory name needs to be changed
    if [ "$file" != "$new_filename" ]; then
      if [ "$dry_run" = true ]; then
        echo "Would rename directory: '$file' -> '$new_filename'"
      else
        mv -v "$file" "$new_filename"
      fi
    else
      if [ "$dry_run" = true ]; then
        echo "Skipping directory: '$file', already correctly named."
      fi
    fi
  else
    # Separate filename and extension using parameter expansion
    filename=$(basename -- "$file")
    extension="${filename##*.}"
    filename="${filename%.*}"

    # Transliterate UTF-8 characters to ASCII using Python unidecode for files
    new_filename=$(echo "$filename" | python3 -c 'import sys, unicodedata; filename = sys.stdin.read().strip(); filename = unicodedata.normalize("NFD", filename).encode("ascii", "ignore").decode("ascii").replace(" ", "-").replace("_", "-").replace("/", "-").replace(".", "-"); filename = "-".join(filter(None, filename.split("-"))); print(filename)')

    # Construct the new filename with the preserved extension
    newname="${new_filename}.${extension}"

    # Check if the filename needs to be changed
    if [ "$file" != "$newname" ]; then
      if [ "$dry_run" = true ]; then
        echo "Would rename file: '$file' -> '$newname'"
      else
        mv -v "$file" "$newname"
      fi
    else
      if [ "$dry_run" = true ]; then
        echo "Skipping file: '$file', already correctly named."
      fi
    fi
  fi
done

Forem: Sérgio Araújo

Neovim translate popup

Neovim Translation with translate-shell and Custom Popup

Prerequisites

1. Install translate-shell

Neovim Implementation

1. Add the translation function

2. Add the keymaps

3. Mnemonic

Features

Demo

Credits

References

Dicas avançadas do firefox

Nem tudo é atalho mas...

Quando o menu de opções sumir

Como instalar extensões?

Tradutor por contexto (seleção)

Bloqueador de anúncios

Captura de tela nativa

Gerenciador de senhas

Logar e sincronizar sua conta do firefox

Salvar favoritos com tags

Editando as tags dos favoritos

Criar um perfil separado do firefox

DWM: Wallpaper change

Automatically change your wallpaper using cron

My crontab:

Drink watter reminder with cron

# Building a Robust Neovim Format Autocommand

Introduction

Utility Functions in text_manipulation.lua

1. trim_whitespace(bufnr)

2. squeeze_blank_lines(bufnr)

3. with_preserved_view(op) (from nvim_utils.lua)

4. format_all(bufnr)

Autocommand Implementation

Explanation of args.buf

Conclusion

📌 Update: Using conform.nvim with a Custom Fallback

New update:

nvim: Telescope toggle cwd

Intro

Finding the root dir

Custom telescope find_files

The keymaps

neovim: Wrap selection into clipboard

Intro

get_clipboard_selection

Wrap visual selected text with fenced code

The keymap

Neovim toggle moody words

neovim: clipboard magic

Intro

If I want copy a text and open in neovim (zsh)

Blockwise mode made easy

Paste the clipboard right away blockwise:

Using only lua api to paste @+ blockwise:

Nvim: Persistent colorscheme choice

Just some steps

You can setup your telescope pickers.colorscheme with:

nvim

Another great neovim smooth scroll plugin

The missing smooth scroll

My personal detox command

The original detox

Utility Functions in `text_manipulation.lua`

1. `trim_whitespace(bufnr)`

2. `squeeze_blank_lines(bufnr)`

3. `with_preserved_view(op)` (from `nvim_utils.lua`)

4. `format_all(bufnr)`

Explanation of `args.buf`

📌 Update: Using `conform.nvim` with a Custom Fallback