VersionUtil.java

package org.apache.archiva.common.utils;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.commons.lang.StringUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Version utility methods.
 */
public class VersionUtil
{
    /**
     * These are the version patterns found in the filenames of the various artifact's versions IDs.
     * These patterns are all tackling lowercase version IDs.
     */
    private static final String versionPatterns[] =
        new String[]{ "([0-9][_.0-9a-z]*)", "(snapshot)", "(g?[_.0-9ab]*(pre|rc|g|m)[_.0-9]*)", "(dev[_.0-9]*)",
            "(alpha[_.0-9]*)", "(beta[_.0-9]*)", "(rc[_.0-9]*)",
//        "(test[_.0-9]*)", -- omitted for MRM-681, can be reinstated as part of MRM-712
            "(debug[_.0-9]*)", "(unofficial[_.0-9]*)", "(current)", "(latest)", "(fcs)", "(release[_.0-9]*)",
            "(nightly)", "(final)", "(incubating)", "(incubator)", "([ab][_.0-9]+)" };

    public static final String SNAPSHOT = "SNAPSHOT";

    public static final Pattern UNIQUE_SNAPSHOT_PATTERN = Pattern.compile( "^(.*)-([0-9]{8}\\.[0-9]{6})-([0-9]+)$" );

    public static final Pattern TIMESTAMP_PATTERN = Pattern.compile( "^([0-9]{8})\\.([0-9]{6})$" );

    public static final Pattern GENERIC_SNAPSHOT_PATTERN = Pattern.compile( "^(.*)-" + SNAPSHOT );

    private static final Pattern VERSION_MEGA_PATTERN =
        Pattern.compile( StringUtils.join( versionPatterns, '|' ), Pattern.CASE_INSENSITIVE );

    /**
     * <p>
     * Tests if the unknown string contains elements that identify it as a version string (or not).
     * </p>
     *
     * <p>
     * The algorithm tests each part of the string that is delimited by a '-' (dash) character.
     * If 75% or more of the sections are identified as 'version' strings, the result is
     * determined to be of a high probability to be version identifier string.
     * </p>
     *
     * @param unknown the unknown string to test.
     * @return true if the unknown string is likely a version string.
     */
    public static boolean isVersion( String unknown )
    {
        String versionParts[] = StringUtils.split( unknown, '-' );

        Matcher mat;

        int countValidParts = 0;

        for ( int i = 0; i < versionParts.length; i++ )
        {
            String part = versionParts[i];
            mat = VERSION_MEGA_PATTERN.matcher( part );

            if ( mat.matches() )
            {
                if ( i == 0 ) // loosen rule to return true if first token matches
                {
                    return true;
                }
                countValidParts++;
            }
        }

        /* Calculate version probability as true if 3/4's of the input string has pieces of
         * of known version identifier strings.
         */
        int threshold = (int) Math.floor( Math.max( (double) 1.0, (double) ( versionParts.length * 0.75 ) ) );

        return ( countValidParts >= threshold );
    }

    /**
     * <p>
     * Tests if the identifier is a known simple version keyword.
     * </p>
     *
     * <p>
     * This method is different from {@link #isVersion(String)} in that it tests the whole input string in
     * one go as a simple identifier. (eg "alpha", "1.0", "beta", "debug", "latest", "rc#", etc...)
     * </p>
     *
     * @param identifier the identifier to test.
     * @return true if the unknown string is likely a version string.
     */
    public static boolean isSimpleVersionKeyword( String identifier )
    {
        Matcher mat = VERSION_MEGA_PATTERN.matcher( identifier );

        return mat.matches();
    }

    public static boolean isSnapshot( String version )
    {
        Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( version );
        if ( m.matches() )
        {
            return true;
        }
        else
        {
            return isGenericSnapshot( version );
        }
    }

    public static String getBaseVersion( String version )
    {
        Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( version );
        if ( m.matches() )
        {
            return m.group( 1 ) + "-" + SNAPSHOT;
        }
        else
        {
            return version;
        }
    }

    /**
     * <p>
     * Get the release version of the snapshot version.
     * </p>
     * 
     * <p>
     * If snapshot version is 1.0-SNAPSHOT, then release version would be 1.0
     * And if snapshot version is 1.0-20070113.163208-1.jar, then release version would still be 1.0
     * </p>
     *
     * @param snapshotVersion snapshot version
     * @return release version
     */
    public static String getReleaseVersion( String snapshotVersion )
    {
        Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( snapshotVersion );

        if ( isGenericSnapshot( snapshotVersion ) )
        {
            m = GENERIC_SNAPSHOT_PATTERN.matcher( snapshotVersion );
        }

        if ( m.matches() )
        {
            return m.group( 1 );
        }
        else
        {
            return snapshotVersion;
        }
    }

    public static boolean isUniqueSnapshot( String version )
    {
        Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( version );
        return m.matches();
    }

    public static boolean isGenericSnapshot( String version )
    {
        return version.endsWith( SNAPSHOT );
    }

    public static String getVersionFromGenericSnapshot( String version )
    {
        Matcher m = GENERIC_SNAPSHOT_PATTERN.matcher( version );
        if ( m.matches() )
        {
            return m.group( 1 );
        }
        return version;
    }
}