🛠️ O Guia Definitivo: Atualização e Publicação do Rust no: crates.io

Mapa definitivo do processo de atualização e publicação de bibliotecas em Rust.

Este raciocínio está perfeitamente alinhado com o que há de mais profissional no mercado. 

Aqui está o seu guia passo a passo, do início ao fim:

• Passo 1: Verificar se existem atualizações

Sim, começamos descobrindo o que há de novo no mercado. O Rust tem uma ferramenta excelente (que você precisa instalar uma única vez no computador) para listar o que está desatualizado.

• Comando para instalar a ferramenta (só faz uma vez na vida):

No powershell:

cargo install cargo-outdated

• Comando para verificar atualizações no projeto:

cargo outdated --root-deps-only

> 💡 *O que ele faz:* Ele lê o seu `Cargo.toml` e mostra uma tabela listando qual versão você está usando e qual é a versão mais recente disponível na internet.

• Passo 2: Aplicar os updates na biblioteca

Dependendo do que o Passo 1 te mostrou, você usará um comando diferente:

Para atualizações comuns (Patch/Minor, ex: v1.1 para v1.2): Como seu arquivo já é flexível, basta rodar:

cargo update

Para atualizações Grandes (Major, ex: jsonwebtoken v10 para v11):

cargo add jsonwebtoken@11

• Passo 3: Rodar as checagens de segurança

Agora aplicamos o nosso "filtro de qualidade" para ver se as atualizações são seguras.

Comando combinado no PowerShell:

cargo clean ; cargo test --all-features ; cargo clippy --all-features --fix

• Passo 4: E se o código quebrar?

Exatamente o que você disse! Se o terminal ficar vermelho com algum erro:

1. Você abre o arquivo que acusou o problema.

2. Ajusta o código para se adaptar à nova versão da dependência.

3. Faz uma nova checagem: Roda o comando do Passo 3 de novo (`cargo test...`). Repita até tudo ficar 100% verde.

Passo 5: Deixar a biblioteca flexível

> ⚠️ Ajuste de ordem: Esse passo só acontece se você usou o `cargo add` no Passo 2 (para uma versão Major). Se você usou apenas o `cargo update`, ela já continua flexível automaticamente e você pode pular este passo!

Se você adicionou uma versão Major nova (ex: `jsonwebtoken = "11.0.0"`), você abre o `Cargo.toml` e apaga os zeros, deixando apenas:

jsonwebtoken = "11"

• Passo 6: Atualizar o CHANGELOG.md

Abra o seu arquivo `CHANGELOG.md` na raiz do projeto e escreva uma nota rápida para os seus usuários saberem o que mudou nessa nova versão. Exemplo:

## [6.1.3] - 2026-05-31

### Atualizado

- Dependências atualizadas para melhor estabilidade e segurança (Tokio, Serde).

- Suporte aprimorado para novas features do Axum.

•  Passo 7: O Ensaio Geral e o Lançamento (Git e Tags)

Aqui juntamos o seu script `bump_version.py`, os testes visuais e os comandos do Git para colocar tudo no ar. Siga esta ordem cirúrgica:

• A) Atualizar a versão nos arquivos com o seu script Python:

python bump_version.py 6.1.3

• B) Formatar o código e simular a publicação para garantir que o crates.io vai aceitar:

cargo fmt ; cargo publish --dry-run

• C) Salvar as alterações no Git (Commit e Push):

git add .

git commit -m "chore: bump version to 6.1.3 e atualiza dependencias"

git push origin main

• D) Criar a Tag do Git (O "marco" na história do seu código):

No mundo de frameworks, criar uma Tag é fundamental para marcar que aquela versão específica do código foi lançada.

git tag -a v6.1.3 -m "Release v6.1.3"

git push origin v6.1.3

• E) Publicar para o mundo de verdade:

Agora sim, o comando final para enviar o rullst-connect (por exemplo) para o registro oficial do Rust:

cargo publish

Atenção ao passo E, é interessante ter um arquivo dentro das pastas: .github/workflows chamado publish.yml para que o github actions faça essa publicação automática após o git push origin.

Pronto! Seguindo esses 7 passos, você acabou de fazer uma manutenção de nível sênior na sua biblioteca. Seus usuários receberão um código limpo, documentado, seguro e rastreável via Git!

"Canivete suíço" do Rust

PowerShell (Windows):

Aqui está o resumo visual e prático de cada comando:

1. cargo clean ; cargo test --all-features

• O que é: O Garantidor de Funcionamento.
• O que faz: O cargo clean apaga o cache antigo de compilações passadas. 
• O cargo test --all-features força o Rust a baixar as novas dependências do zero absoluta e roda todos os testes de todas as partes do seu framework (Axum, Actix, Leptos, etc.).
• Quando usar: Sempre após atualizar dependências (como alertas do Dependabot) ou antes de enviar seu código para o GitHub, para ter certeza absoluta de que nada quebrou.

2. cargo clippy --all-features --fix

• O que é: O Mentor de Código.
• O que faz: Analisa o seu código procurando por gambiarras, falta de padrões ou códigos ineficientes. 
• A flag --fix altera o seu arquivo automaticamente corrigindo os problemas mais simples sozinho.
• Quando usar: Antes de finalizar qualquer funcionalidade nova. 
• É o comando que garante que o código do Rullst pareça escrito por um especialista em Rust.

3. cargo fmt --check

• O que é: O Fiscal de Estética.
• O que faz: Verifica se o seu código está formatado exatamente com as regras visuais oficiais do Rust (espaços, chaves, alinhamento). 
• Se você tirar o --check (cargo fmt), ele arruma o código sozinho.
• Quando usar: Antes de fazer um commit. 
• Garante que qualquer desenvolvedor no mundo consiga ler o código do Rullst de forma confortável.

4. cargo doc --all-features --no-deps --open

• O que é: O Criador de Manuais.
• O que faz: Pega os seus comentários de código (com ///) e gera um site HTML de documentação lindo e profissional, abrindo-o direto no seu navegador. 
• O --no-deps faz ele ignorar as bibliotecas dos outros e focar só na sua.
• Quando usar: Quando estiver escrevendo novas funções ou APIs para ver como a documentação do Rullst está ficando para os seus usuários finais.

5. cargo publish --dry-run

• O que é: O Ensaio Geral.
• O que faz: Simula todo o processo de empacotamento e envio da sua biblioteca para o site oficial (crates.io). 
• Ele finge que vai publicar para checar se não falta nenhum arquivo ou configuração, mas não envia nada para a internet ainda.
• Quando usar: O último passo antes de lançar uma versão nova. 
• Se ele passar sem erros, significa que o seu pacote está pronto para o mundo.

💡 Resumo do fluxo de trabalho (A Ordem Perfeita):

Quando você estiver trabalhando no Rullst, a ordem natural de uso deles é:

1. Digita o código 
2. cargo clippy (arruma a lógica) 
3. cargo fmt (arruma a beleza) 
4. cargo test (valida tudo) 
5. cargo publish --dry-run (valida o lançamento).