Reformatação e controle de versão

A formatação de código é importante. Mesmo o recuo é importante . E a consistência é mais importante que pequenas melhorias. Mas os projetos geralmente não têm um guia de estilo claro, completo, verificável e aplicado desde o primeiro dia, e grandes melhorias podem chegar a qualquer dia. Talvez você ache isso

SELECT id, name, address
FROM persons JOIN addresses ON persons.id = addresses.person_id;

poderia ser melhor escrito como / é melhor escrito do que

SELECT persons.id,
       persons.name,
       addresses.address
  FROM persons
  JOIN addresses ON persons.id = addresses.person_id;

enquanto trabalhava na adição de mais colunas à consulta. Talvez essa seja a mais complexa das quatro consultas em seu código ou uma consulta trivial entre milhares. Não importa quão difícil seja a transição, você decide que vale a pena. Mas como você controla as alterações de código nas principais alterações de formatação? Você pode simplesmente desistir e dizer "este é o ponto em que começamos novamente" ou pode reformatar todas as consultas em todo o histórico do repositório.

Se você estiver usando um sistema de controle de versão distribuído como o Git, poderá reverter para o primeiro commit de todos os tempos e reformatar o caminho para o estado atual. Mas é muito trabalho, e todo mundo teria que interromper o trabalho (ou estar preparado para a mãe de todas as fusões) enquanto isso acontecia. Existe uma maneira melhor de alterar o histórico que oferece o melhor de todos os resultados:

• Mesmo estilo em todas as confirmações
• Trabalho de mesclagem mínima

?

Para esclarecer, não se trata de práticas recomendadas ao iniciar o projeto, mas o que deve ser feito quando uma grande refatoração for considerada uma Boa Coisa ™, mas você ainda deseja um histórico rastreável? Nunca reescrever o histórico é ótimo se for a única maneira de garantir que suas versões sempre funcionem da mesma forma, mas e os benefícios do desenvolvedor de uma reescrita limpa? Especialmente se você tiver maneiras (testes, definições de sintaxe ou um binário idêntico após a compilação) para garantir que a versão reescrita funcione exatamente da mesma maneira que a original?

Faça a reformatação como confirmações separadas. Isso interferirá minimamente no histórico, e você poderá ver rapidamente quais confirmações estão apenas reformatando e que realmente alteram o código. Poderia distorcer git blamee semelhante, mas se apontar para um commit somente de reformatação, é bastante simples procurar a alteração anterior antes disso.

Não reescreva a história do VCS: é contra os princípios do VCS.

Não tente automatizar a correção da formatação: está tratando os sintomas, não o problema real (= desenvolvedores que não seguem os padrões de codificação).

Defina o padrão de codificação e as melhores práticas de formatação em um documento comum e peça a todos os desenvolvedores que concordem.

Você menciona o Git, o que é ótimo, porque é distribuído. Com um DVCS, é muito fácil aplicar as melhores práticas por meio do fluxo de trabalho do gatekeeper . Os gatekeepers rejeitam propostas de mesclagem (= solicitações de recebimento no Git) que não estão em conformidade com as diretrizes comuns. E quero dizer rejeitar , em negrito, caso contrário, o codificador violado não se preocupará em seguir as regras e continuar repetindo os mesmos erros.

Essa técnica funciona bem para mim. Os programadores desejam que seu trabalho seja mesclado; portanto, após alguns erros no começo, eles começam a seguir as regras.

De acordo com a correção da base de código existente ... eu recomendo fazer isso gradualmente, talvez módulo por módulo, ou como faz sentido para o seu projeto. Teste com cuidado em cada etapa. Pode parecer estúpido, mas erros acontecem mesmo com mudanças triviais, como apenas a formatação, portanto, esteja preparado para alguns pequenos inchaços na estrada.

A resposta para sua pergunta real é: "Você não". Não conheço nenhuma ferramenta SCM atual que possa rastrear alterações na lógica do código formatado de uma maneira, através de uma grande alteração de formatação e de outras alterações após o código ser formatado da nova maneira. E, você sabe disso, perder o histórico de um pedaço de código não é bom.

Consequentemente, vou contradizer um pouco sua primeira frase. Código formatação não importa que muito. Pretty é legal, mas não é para isso que estamos aqui. Eu entendo, assim como qualquer pessoa, que ser despejado no antigo código variante K&R de alguém com os dois espaços recuados é uma porcaria (1), mas ... a formatação não é realmente um obstáculo para entender o que está acontecendo, a menos que seja algo excepcionalmente patológico. E, nesse caso, você terá problemas para alterar o código de qualquer maneira e não deve incomodá-lo.

Portanto, não vale a pena fazer alterações no código estabelecido estritamente para reformatá-lo. Mudando os nomes das variáveis, dividindo funções longas, todas as coisas boas de refatoração que alteram o conteúdo, sim, mas não APENAS reformatando.

1) - Eu já possuía o Windows Clipboard Viewer por um tempo. A coisa toda era um módulo C de 150k. Encontrei um local em que diferentes pessoas usaram, penso eu, cinco estilos de aparelhos diferentes, a trinta linhas uma da outra. Mas essa seção de coisas funcionou. Eu carreguei uma impressão desse pedaço de código por dez anos, mas não o cutuquei porque esse histórico importava, e esse código estava em pelo menos três árvores de origem (Windows 3.x, NT, futuro 95) que viviam em diferentes edifícios.

Mas como você controla as alterações de código nas principais alterações de formatação?

Alterações de formatação são alterações de código; trate-os como faria com qualquer outra alteração no seu código. Qualquer um que tenha trabalhado em um projeto significativo provavelmente já viu bugs e outros problemas criados quando alguém decidiu "apenas" reformatar algum código.

Mas é muito trabalho, e todo mundo teria que interromper o trabalho (ou estar preparado para a mãe de todas as fusões) enquanto isso acontecia.

Por que você tem que reformatar tudo ao mesmo tempo? Especialmente se a reformatação não alterar o significado do código, você poderá reformatar os arquivos individualmente e registrá-los à medida que avança. Melhor, peça a todos da equipe que concordem com um estilo (caso contrário, não há sentido em reformatar de qualquer maneira) e peça a todos que cuidem da reformatação no decorrer de seus outros trabalhos. Depois de um tempo, você terá coberto a maior parte do código sem interromper o restante do projeto.

Existem duas abordagens viáveis ​​que eu já vi para isso.

1. Reformate o código no commit-hook

Embora inicialmente seja arrepiante alterar o código após o envio , se o procedimento de reformatação (por exemplo, astyle ) não prejudicar o código, será uma operação segura. Com o tempo, toda a equipe perceberá que todo o código parece o mesmo. Claramente, ter testes abrangentes de unidade / automatizados garantirá que nada ocorra.

2. Reformatação única de todo o código

Isso é mais perigoso na minha experiência e dificulta os problemas de rastreamento no big bang, mas é possível. A execução de todos os testes depois é essencial. Para o estilo de codificação, a maioria das diferenças gira em torno do uso de espaço em branco - recuo ou novas linhas. Uma ferramenta de mesclagem decente deve poder ser instruída a ignorar todas as diferenças de espaço em branco, portanto, isso ajudará nas mesclagens.