Este repositório é dedicado ao estudo e aplicação de práticas de Controle de Versão e Conventional Commits, fundamentais para a colaboração eficiente e gestão de projetos de software.
Aqui é explorada a importância do Controle de Versão, o papel dos commits no desenvolvimento de software, e como a adoção de Conventional Commits pode melhorar significativamente a clareza e utilidade das mensagens de commit, servindo como um recurso de consulta aqueles que desejam adotar padrões de commits que facilitam a manutenção e colaboração em projetos de software.
- Controle de Versão e Conventional Commits
- Commit e Controle de Versão
- Conventional Commits
- Como Utilizar Conventional Commits
- Tipos de Conventional Commits
- feat: Novas Funcionalidades
- fix: Correções de Bugs
- docs: Documentação
- refactor: Refatoração
- test: Testes
- perf: Performance
- style: Estilo
- build: Processo de Build
- ci: Integração Contínua
- config: Configurações
- access: Acessibilidade
- data: Manipulação de Dados
- security: Segurança
- dependency: Dependências
- chore: Tarefas Diversas
- revert: Reverter
- merge: Fusão de Branches
- release: Lançamentos
- cleanup: Limpeza de Código
- experiment: Experimentações
- Boas Práticas
- Referências Úteis
O Controle de Versão registra alterações em um arquivo ou conjunto de arquivos ao longo do tempo, permitindo que você recupere versões específicas posteriormente. Essa prática é fundamental no desenvolvimento de software, onde muitos desenvolvedores estão manipulando o mesmo código-fonte.
-
Colaboração Eficiente: Facilita o trabalho simultâneo de vários desenvolvedores em um único projeto, minimizando conflitos de código.
-
Histórico Completo: Cada alteração feita no repositório é rastreada, incluindo o autor, a descrição da alteração e a data, o que simplifica a compreensão da evolução do projeto.
-
Gestão de Releases: Permite marcar pontos específicos na história do projeto como importantes (releases) facilitando o gerenciamento de versões estáveis.
-
Desfazer Alterações: Oferece a possibilidade de reverter para versões anteriores do projeto, o que é crucial para a correção de erros ou a descontinuação de funcionalidades indesejadas.
-
Experimentação e Branching: Os desenvolvedores podem criar ramificações (branches) isoladas para experimentar novas ideias sem afetar o código principal, promovendo a experimentação segura.
-
Recuperação de Desastres: Em caso de falhas críticas ou perda de dados, o sistema de controle de versão atua como uma rede de segurança, permitindo uma recuperação rápida e eficaz para estados anteriores estáveis do software.
-
Integração e Deploy: Modernos sistemas de controle de versão estão frequentemente integrados com pipelines de CI/CD (Integração Contínua/Delivery Contínuo), automatizando testes e deploy, o que aumenta a eficiência e a confiabilidade do lançamento de novas versões do software.
-
Escalabilidade: À medida que os projetos de software crescem em complexidade e tamanho de equipe, o controle de versão se torna ainda mais crucial. Ele suporta a expansão sem sacrificar a organização ou a integridade do projeto.
O Controle de Versão é essencial para o desenvolvimento de software moderno, promovendo a colaboração, a segurança e a eficiência no gerenciamento de projetos.
Um "commit" é uma gravação de alterações feitas no código-fonte ou em arquivos de um projeto de software em um repositório de controle de versão. Ele atua como uma "fotografia" do estado atual do projeto, permitindo que os desenvolvedores documentem o progresso e façam anotações sobre as mudanças realizadas. Cada commit inclui uma mensagem explicativa que fornece contexto sobre o que foi alterado e por quê, facilitando a compreensão do histórico do projeto.
Commits são fundamentais no desenvolvimento de software, atuando como marcos individuais que documentam a evolução de um projeto. Eles são mais do que simples atualizações; cada commit encapsula um progresso significativo ou uma correção essencial, tornando-o uma parte intrínseca da narrativa do desenvolvimento.
-
Documentação Precisa: Cada commit oferece uma descrição detalhada do que foi alterado, servindo como uma documentação precisa que facilita o entendimento das modificações realizadas ao longo do tempo.
-
Responsabilidade: Ao associar cada conjunto de alterações a um autor específico, os commits fomentam um ambiente de responsabilidade, onde cada contribuição pode ser atribuída a um indivíduo.
-
Milestones de Desenvolvimento: Os commits podem ser utilizados como pontos de referência para o progresso do projeto, ajudando na organização de tarefas e na definição de objetivos claros de desenvolvimento.
-
Facilitação de Revisões: Os commits permitem que as revisões de código sejam mais estruturadas e focadas, já que cada commit é uma unidade de mudança que pode ser analisada isoladamente.
-
Suporte à Colaboração Assíncrona: Em um ambiente de trabalho distribuído, os commits permitem que os membros da equipe contribuam e atualizem o projeto em seus próprios horários, mantendo a continuidade do desenvolvimento.
Conventional Commits são convenções de nomenclatura para mensagens de commit que enfatizam com clareza as modificações realizadas. Essa abordagem padroniza as mensagens de commit, tornando-as mais informativas e fáceis de entender.
Eles são estruturados de forma a destacar o tipo de mudança feita, o escopo da mudança, e uma descrição clara da alteração ou adição.
- Comunicação Clara: Proporcionam uma visão imediata do tipo de alterações incluídas em um commit, facilitando a revisão de código e o entendimento rápido das mudanças.
-
Histórico Organizado: Contribuem para um histórico de projeto mais organizado e pesquisável, permitindo que desenvolvedores compreendam rapidamente a natureza das alterações.
-
Facilitação de Rollbacks: Em casos de necessidade de reverter mudanças, a clareza nas mensagens de commit permite identificar rapidamente quais commits devem ser revertidos ou ajustados.
-
Integração Contínua: Com mensagens padronizadas, é possível automatizar partes do processo de integração contínua, como a execução de testes específicos com base no tipo de commit.
-
Melhoria na Colaboração: A padronização de mensagens melhora significativamente a colaboração em equipe, pois todos os membros têm expectativas claras sobre a estrutura e o conteúdo das mensagens de commit.
-
Gerenciamento de Versões Semânticas: Facilita o uso de versões semânticas ao permitir que ferramentas automatizadas incrementem números de versão com base no tipo de alterações indicadas pelas mensagens de commit.
Adotar Conventional Commits é uma prática que reforça a disciplina e a clareza no registro de mudanças, beneficiando não apenas o processo de desenvolvimento individual, mas também a colaboração em equipe e a gestão eficaz do ciclo de vida do software.
- Estrutura da Mensagem: Cada mensagem de commit deve ter um cabeçalho, composto por um tipo, um escopo opcional, e uma descrição.
- A estrutura básica é:
<tipo>[escopo opcional]: <descrição>.
-
Escopo: Opcionalmente, inclua um escopo que esclareça o contexto da alteração. O escopo pode ser o nome de um módulo ou componente.
-
Descrição: A descrição deve ser concisa e explicar o motivo da alteração, não o que foi mudado.
Adiciona novas funcionalidades ou melhorias significativas ao projeto.
- feat(auth): implementa autenticação baseada em JWT
- feat(ui): adiciona tema escuro
- feat(api): suporta filtragem de dados na API de usuários
Corrige problemas no código que afetam o comportamento esperado do software.
- fix(login): corrige redirecionamento após o login
- fix(cart): ajusta cálculo de total quando item é removido
- fix(email): resolve problema de codificação em e-mails enviados
Atualiza ou melhora a documentação do projeto.
- docs(readme): atualiza instruções de instalação
- docs(changelog): adiciona notas de release para a versão 2.1
- docs(api): melhora documentação dos endpoints
Melhora a estrutura interna do código sem alterar seu comportamento externo.
- refactor(cart): simplifica lógica de adição de itens
- refactor(utils): unifica funções de formatação de data
- refactor(api): separa rotas em diferentes arquivos para clareza
Adiciona ou altera testes automatizados.
- test(auth): adiciona testes para o fluxo de autenticação
- test(ui): implementa testes para o novo componente de carrossel
- test(api): aumenta cobertura de testes para o controller de usuário
Melhora a performance e eficiência do software.
- perf(api): otimiza consulta de banco de dados para listagem de produtos
- perf(images): implementa lazy loading para imagens na homepage
- perf(build): reduz tamanho do bundle através de tree shaking
Ajusta espaços em branco, formatação e outros elementos que não alteram o significado do código.
- style(lint): corrige warnings de lint em vários arquivos
- style(format): aplica formatação com Prettier
- style(comments): remove comentários obsoletos
Altera o sistema de build ou atualiza dependências externas.
- build(webpack): atualiza para a versão mais recente do Webpack
- build(deps): atualiza React para a versão mais recente
- build(ci): adiciona etapa de lint ao pipeline de CI
Modifica arquivos e scripts de CI/CD.
- ci(github-actions): adiciona job para testes de integração
- ci(travis): corrige script de deploy
- ci(docker): otimiza Dockerfile para build mais rápido
Modifica configurações do projeto.
- config(eslint): adiciona regra para proibir uso de var
- config(prettier): ajusta largura máxima da linha para 100 caracteres
- config(editor): adiciona arquivo .editorconfig
Melhora a acessibilidade do software.
- access(buttons): adiciona atributos aria a botões sem texto
- access(colors): ajusta contraste de cores para melhor leitura
- access(navigation): melhora navegação por teclado no menu principal
Gerencia e manipula dados.
- data(schema): atualiza esquema do banco de dados para suportar novos campos
- data(migration): adiciona script de migração para a nova versão do esquema
- data(seed): adiciona dados de exemplo para desenvolvimento
Melhora a segurança do software.
- security(auth): corrige vulnerabilidade de injeção de SQL no login
- security(deps): atualiza bibliotecas com vulnerabilidades conhecidas
- security(https): força HTTPS em todas as páginas
Gerencia dependências do projeto.
- dependency(upgrade): atualiza lodash para a versão mais recente
- dependency(remove): remove biblioteca não utilizada xyz
- dependency(add): adiciona axios para requisições HTTP
Realiza tarefas de manutenção que não se encaixam em outras categorias.
- chore(cleanup): remove arquivos temporários
- chore(release): prepara para a versão 1.2.0
- chore(repo): atualiza .gitignore
Indica a reversão de um commit anterior.
- revert: reverter "feat(login): add captcha to login form"
- revert: reverter "chore: update dependencies"
- revert: reverter "fix(cart): correct item count"
Representa a fusão de branches no projeto.
- merge(feature/cool-feature): mescla branch de funcionalidade no main
- merge(hotfix/login): mescla correção de emergência no main
- merge(release/1.2): mescla branch de release no main
Marca um novo lançamento ou versão do projeto.
- release(1.2.0): lança versão 1.2.0
- release(2.0.0-beta): lança versão beta 2.0.0
- release(1.1.5): lança patch version 1.1.5
Remove código, arquivos ou dependências não utilizados ou obsoletos.
- cleanup(unused-vars): remove variáveis não utilizadas
- cleanup(old-files): deleta arquivos antigos de design
- cleanup(deps): remove pacotes não utilizados
Realiza experimentações ou testes de novas ideias.
- experiment(new-algo): testa novo algoritmo de recomendação
- experiment(feature-flag): adiciona flag de funcionalidade para teste
- experiment(ui): testa novo layout para a página inicial
-
Mensagens Atômicas: Cada commit deve representar uma mudança atômica e lógica. Não agrupe alterações não relacionadas.
-
Uso de Verbos no Imperativo: Escreva a descrição do commit no imperativo: "Adiciona recurso", "Corrige bug", etc.
-
Mensagens Claras e Descritivas: A descrição deve ser clara o suficiente para que, ao ler a mensagem do commit, outros membros da equipe possam entender o propósito da alteração sem ter que ler o código.
-
Consistência: Adote um padrão consistente para as mensagens de commit em todo o projeto, facilitando a leitura do histórico de commits.
Ao seguir estas diretrizes, o uso de Conventional Commits ajuda a manter um histórico de commits claro e legível, facilita a geração automatizada de changelogs, e melhora a comunicação e colaboração dentro de equipes de desenvolvimento de software.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent