Como o maven classifica os números da versão?

O Maven parece ter a capacidade de indicar um intervalo de versões como [1.2.3,) como o maven descobre o que é uma versão mais nova ou mais antiga quando não há um esquema de versionamento consistente que todo o código aberto pacotes seguem. Por exemplo

  • junit 4.10
  • slf4j 1.7.2
  • Hibernate 4.1.7.Final
  • spring 3.1.2.RELEASE

Como o maven figura o que é uma versão antiga vs. mais recente de um pacote no maven? E se o pacote usa letras como números de versões algo ao longo das linhas de A, B, C ou A2, A2, A4 … etc.

Existe uma maneira oficial padrão de pacotes de versão no maven? Os pacotes comuns de código aberto, como spring e hibernate, ignoram esta convenção de versionamento?

De acordo com esta referência , o Maven requer que a versão seja da seguinte forma:

. . -

Onde MajorVersion , MinorVersion , IncrementalVersion e BuildNumber são todos numéricos e Qualifier é uma string. Se o número da sua versão não corresponder a esse formato, todo o número da versão será tratado como sendo o Qualificador .

A referência vai para explicar que você pode “enfrentar problemas” (particularmente com intervalos de versão Maven) se você trabalha com artefatos que não seguem este esquema de versionamento. Observar o código-fonte do Maven que está vinculado ao artigo é bastante útil.

Dos exemplos que você deu, os artefatos do Hibernate e Spring parecem se desviar no uso de ” . ” Ao invés de ” - ” para separar o qualificador.

Alguma experimentação de minha parte mostra que DefaultArtifactVersion irá analisar os números de versão exatamente como descrito acima. Ou seja, o exemplo da Spring fornecido ( 3.1.2.RELEASE ) será interpretado como:

  • Maior: 0
  • Menor: 0
  • Incremental: 0
  • Qualificador: 3.1.2.RELEASE

Mais importante, a comparação de dois números de versão (se usar o Maven 3.0 ou mais recente) é muito mais flexível. Os números de versão são divididos em listas de itens (onde . Ou - marca o limite entre os itens, observe que . Tem uma prioridade mais alta que - ). A comparação é então realizada tomando cada item a termo e realizando uma comparação de ordem natural. Portanto 3.1.2.RELEASE será visto como menor que 3.1.3.RELEASE . Strings são comparados também, portanto, 3.1.2.RELEASD será visto como menor que 3.1.2.RELEASE . Existem algumas cadeias especiais que têm equivalentes especiais, por exemplo, 3.1.3.a.1 o mesmo que 3.1.3.alpha.1

No entanto, enquanto a comparação é mais flexível em versões mais recentes do Maven. Os limites do intervalo de versão ainda são avaliados usando o esquema Major: Minor: Incremental: Qualifier, portanto, se você estiver usando intervalos de versão, a flexibilidade será menos útil.

Desde a versão 3.0, o Maven usa um sistema consistente para comparar números de versão para versões individuais e intervalos de versão. O sistema agora faz muito sentido, uma vez que você entendeu algumas dicas.

Todas as comparações são feitas agora por ComparableVersion , que diz:

  • mistura de ‘ - ‘ (traço) e ‘ . Separadores (ponto),
  • transição entre caracteres e dígitos também constitui um separador: 1.0alpha1 => [1, 0, alpha, 1]
  • número ilimitado de componentes de versão,
  • componentes da versão no texto podem ser dígitos ou strings,
  • Seqüências de caracteres são verificadas para qualificadores conhecidos e o qualificador é usado para ordenação de versões. Qualificadores bem conhecidos (sem distinção entre maiúsculas e minúsculas) são:
    • alpha ou a
    • beta ou b
    • milestone ou m
    • rc ou cr
    • snapshot
    • (a string vazia) ou ga ou final
    • sp
  • Qualificadores desconhecidos são considerados após qualificadores conhecidos, com ordem lexical (sempre insensível a maiúsculas),
  • um traço geralmente precede um qualificador e é sempre menos importante do que algo precedido por um ponto.

Isso significa que as versões saem na seguinte ordem, o que eu acho que faz todo o sentido, além do 1.0-SNAPSHOT bem no meio:

  • 1.0-beta1-SNAPSHOT
  • 1.0-beta1
  • 1.0-beta2-SNAPSHOT
  • 1.0-rc1-SNAPSHOT
  • 1.0-rc1
  • 1.0-SNAPSHOT
  • 1.0
  • 1.0-sp
  • 1.0-whatever
  • 1.0.1

A principal pegadinha que eu encontrei em tudo isso é que o snapshot vem depois de beta ou rc , então você não pode ter uma versão de desenvolvimento do 1.0-SNAPSHOT , então libere 1.0-beta1 ou 1.0-rc1 e faça Maven entender que eles são posteriores.

Observe também que 1.0-beta-1 é exatamente o mesmo que 1.0beta1 e 1.0 é exatamente o mesmo que 1 ou 1.0.0 .

Os intervalos de versão agora funcionam (quase) da maneira que você esperaria também. Por exemplo, [1.0-alpha-SNAPSHOT,1.0] encontrará 1.0-beta1-SNAPSHOT , 1.0-beta1 , 1.0-rc1-SNAPSHOT , 1.0-rc1 , 1.0-SNAPSHOT ou 1.0 , preferindo itens posteriores aos anteriores. Isso é totalmente suportado por mvn versions:resolve , M2Eclipse e assim por diante.

Este é um teste que foi escrito diretamente contra a class ComparableVersion do Maven.

 package org.codehaus.mojo.buildhelper.versioning; import org.apache.maven.artifact.versioning.ComparableVersion; import org.junit.Assert; import org.junit.Test; public class TempTest { @Test public void testVersions() { Assert.assertTrue(new ComparableVersion("1.0-beta1-SNAPSHOT").compareTo( new ComparableVersion("1.0-beta1")) < 0); Assert.assertTrue(new ComparableVersion("1.0-beta1").compareTo( new ComparableVersion("1.0-beta2-SNAPSHOT")) < 0); Assert.assertTrue(new ComparableVersion("1.0-beta2-SNAPSHOT").compareTo( new ComparableVersion("1.0-rc1-SNAPSHOT")) < 0); Assert.assertTrue(new ComparableVersion("1.0-rc1-SNAPSHOT").compareTo( new ComparableVersion("1.0-rc1")) < 0); Assert.assertTrue(new ComparableVersion("1.0-rc1").compareTo( new ComparableVersion("1.0-SNAPSHOT")) < 0); Assert.assertTrue(new ComparableVersion("1.0-SNAPSHOT").compareTo( new ComparableVersion("1.0")) < 0); Assert.assertTrue(new ComparableVersion("1.0").compareTo( new ComparableVersion("1")) == 0); Assert.assertTrue(new ComparableVersion("1.0").compareTo( new ComparableVersion("1.0-sp")) < 0); Assert.assertTrue(new ComparableVersion("1.0-sp").compareTo( new ComparableVersion("1.0-whatever")) < 0); Assert.assertTrue(new ComparableVersion("1.0-whatever").compareTo( new ComparableVersion("1.0.1")) < 0); } } 

Este teste afirma que as seguintes versões são consideradas do menor para o maior pelo Maven:

  • 1.0-beta1-INSTANTÂNEO
  • 1,0-beta1
  • 1.0-beta2-SNAPSHOT
  • 1.0-rc1-SNAPSHOT
  • 1.0-rc1
  • 1.0-SNAPSHOT
  • 1,0 e 1 (são iguais)
  • 1,0-sp
  • 1.0-whatever
  • 1.0.1

Sua suposição sobre o uso de major / minor / incremtal / etc. é simplesmente errada. A comparação é feita em ComparableVersion, que contém a implementação. O ctor chamará parseVersion(...) que usa ComparableVersion que é armazenada como instância no DefaultArtifactVersion e é usada durante a compareTo(..)

Há partes como getMajor.. , etc., mas elas não estão funcionando corretamente. Esta é a razão pela qual será marcada como obsoleta .

A informação de Stehpen Collony é verdadeira para o Maven 2, mas não para o Maven 3.