Por que o build.number é um "abuso" do controle de versão semântico?

Eu estava explicando um sistema de construção proposto (Gradle / Artifactory / Jenkins / Chef) a um de nossos arquitetos seniores, e ele fez um comentário para mim que eu meio que discordo, mas não tenho experiência suficiente para pesar.

Este projeto constrói uma biblioteca Java (JAR) como um artefato a ser reutilizado por outras equipes. Para controle de versão, eu gostaria de usar a abordagem semântica de:

<major>.<minor>.<patch>

Onde patchindica correções de bugs / emergência, minorindica versões compatíveis com versões anteriores e majorindica refatorações em massa da API e / ou alterações incompatíveis com versões anteriores.

No que diz respeito à entrega, aqui está o que eu quero: um desenvolvedor compromete algum código; isso aciona uma construção em um ambiente de controle de qualidade / teste. Alguns testes são executados (alguns automatizados, outros manuais). Se todos os testes forem aprovados, uma compilação de produção publica o JAR em nosso repositório interno. A essa altura, o JAR deveria ser versionado corretamente, e meu pensamento era usar o build.numberque é gerado automaticamente e fornecido por nossa ferramenta de CI para atuar como o número do patch.

Assim, o versionamento seria realmente:

<major>.<minor>.<build.number>

Novamente, onde build.numberé fornecido pela ferramenta de IC.

O arquiteto descartou isso, dizendo que o uso do número de compilação do IC era um "abuso" do controle de versão semântico.

Minha pergunta é: isso está correto? Em caso afirmativo, por quê? E se não, por que não?

— herpylderp
fonte

Respostas:

O número da sua compilação não será redefinido para 0, quando as versões principais e secundárias aumentarem, isso viola as seções 7 e 8 das especificações :

A versão secundária Y (xYz | x> 0) DEVE ser incrementada se uma nova funcionalidade compatível com versões anteriores for introduzida na API pública. DEVE ser incrementado se alguma funcionalidade pública da API estiver marcada como obsoleta. Pode ser incrementado se novas funcionalidades substanciais ou melhorias forem introduzidas no código privado. PODE incluir alterações no nível do patch. A versão do patch DEVE ser redefinida para 0 quando a versão secundária for incrementada.

A versão principal X (Xyz | X> 0) DEVE ser incrementada se quaisquer alterações incompatíveis com versões anteriores forem introduzidas na API pública. PODE incluir alterações menores e no nível do patch. O patch e a versão secundária DEVEM ser redefinidos para 0 quando a versão principal for incrementada.

Portanto, os números de versão (major, minor, patch) devem ser fornecidos manualmente, pois são usados para informar seus usuários sobre alterações em um único local, sem que eles precisem consultar o seu registro de alterações ou algum outro documento.

Se você deseja incluir o número da sua compilação, pode adicioná-los após a +(seção 10):

Os metadados da compilação podem ser indicados anexando um sinal de mais e uma série de identificadores separados por pontos imediatamente após o patch ou a versão de pré-lançamento. Identificadores DEVEM incluir apenas alfanuméricos ASCII e hífen [0-9A-Za-z-]. Identificadores NÃO DEVEM estar vazios. Os metadados da compilação DEVEM ser ignorados ao determinar a precedência da versão. Portanto, duas versões que diferem apenas nos metadados da compilação têm a mesma precedência. Exemplos: 1.0.0-alfa + 001, 1.0.0 + 20130313144700, 1.0.0-beta + exp.sha.5114f85.

— Resíduo
fonte

Acompanhamento rápido @Residuum (e BTW +1 para a resposta): os números de versão sempre devem ser derivados manualmente? Caso contrário, quais ferramentas poderiam ser usadas no lugar do número de IC / build?

— precisa saber é o seguinte

@herpylderp de jeito nenhum, as especificações de Tom Preston-Werner são apenas sua opinião, muitas outras empresas têm padrões diferentes (geralmente muito parecidos entre si). Na maioria deles, um número gerado automaticamente faz parte da versão. Usar o número de compilação do IC é uma coisa sensata a ser feita.

— Gbjbaanb

Você ainda pode usar a ferramenta CI, se a ferramenta permitir que você faça aritmética nos números de compilação. Qualquer que seja a versão que você libere como atualização de versão principal ou secundária, conecte esse número de versão a uma expressão da sequência de versões que subtrai do número de versão atual do IC. Você acabou de redefinir seu número de compilação para zero para a nova versão, sem redefinir seu número de compilação.

— Keiths

Quanto a mim, eu apenas uso [major]. [Minor]. [Revisão]. [SVN-Version] para DLLs e [major]. [Minor]. [SVN-Version] para instaladores. O número de compilação do IC é apenas para uso interno, para mostrar onde uma compilação que falhou pode ter sido executada exatamente na mesma base de código após uma alteração no ambiente do IC (instalação de um certificado de chave, adição de bibliotecas comuns ao GAC etc.).

— Keiths

@gbjbaanb et al .: em todas as discussões sobre "versão semântica" das quais eu fazia parte, a definição do semver.org era o assunto. Pesquise na web por "versionamento semântico" e pelo menos a primeira página apresentará prós / contras sobre a definição do semver.org . Você é livre para usar seus próprios esquemas de versão, mas não o chame de versão semântica, pois esse termo está claramente definido.

— Residuum 18/08/14

Um dos motivos é que o patch pode exigir várias compilações; portanto, se você possui a versão 5.7 e deseja corrigi-lo para a 5.7.1, mas suas duas primeiras correções não são compiladas quando enviadas ao sistema de IC, você será na 5.7.3 antes de você lançar seu primeiro patch!

A resposta é simplesmente usar 4 dígitos (como os sistemas Microsoft costumam ter). O quarto é um número de compilação e é usado "apenas para informação". Geralmente, as pessoas colocam o número da versão do repositório (se eles usam SVN, TFS ou similar), o que é muito bom, pois você pode verificar qual confirmação exata foi usada para criar os binários. Se você não tem esse tipo de coisa, o número de compilação do IC é uma aproximação razoável (como seria de esperar que o sistema do IC se lembre dos números da compilação e vincule-o ao histórico do repo, mas você não depende do IC sistema lembrando-os - você nunca pode excluir versões antigas).

Uma coisa a observar, o esquema da Microsoft para controle de versão usa a terceira posição para criar números. O Chrome usa apenas 1 número. O Ubuntu usa a data. Não há "padrão" a ser usado , exceto que todos os números devem ser incrementados.

— gbjbaanb
fonte

Embora não exista um padrão universalmente usado ou imposto, a pergunta parece ser especificamente sobre o controle de versão semântico, que possui uma especificação.

— Doval

Mesmo isso está quebrado no campo, por exemplo, o versionamento do NuGet da Microsoft usa semver, de maneira interrompida (usando o estilo de pré-lançamento para números de compilação), e Ruby usa major.minor.teeny.patch . De qualquer forma, como o número da compilação pode fazer parte do semver, o arquiteto estava falando tosh (embora seja certo que deveria ser + compilação, não na 3ª posição).

— Gbjbaanb

A especificação do SemVer 2.0 é de 2013 e a especificação 1.0 é de 2012, tanto quanto eu posso dizer. É provável que NuGet e Ruby estivessem fazendo suas próprias coisas antes que as especificações aparecessem. Não é como se as especificações do SemVer fossem novas; apenas formaliza o que as pessoas já estão fazendo, para que todos possamos finalmente concordar em uma maneira de fazê-lo, em vez de uma dúzia de variações.

— Doval

"você tem a versão 5.7 e deseja corrigi-la para a 5.7.1, mas suas duas primeiras correções não são compiladas quando enviadas ao sistema de CI, então você estará na 5.7.3 antes de lançar seu primeiro patch ! " ok, mas e daí? Não me lembro de nada dizendo que os números não devam pular.

— 216 Andy