components/dotnet-vendor/src/main/java/npanday/vendor/impl/VersionMatcher.java

/*
 * 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.
 */
package npanday.vendor.impl;

import java.util.regex.Pattern;
import java.util.Iterator;
import java.util.Set;

import npanday.vendor.InvalidVersionFormatException;

/**
 * Provides a way to match versions.
 *
 * @author Shane Isbell
 */
final class VersionMatcher
{
    /**
     * A pattern for a valid version format: \p{Alnum}[._-]]*[+*]?. This will be used for determining whether a
     * version is valid.
     */
    private static Pattern versionIdMatch = Pattern.compile( "[\\p{Alnum}[._-]]*[+*]?" );

    /**
     * Constant denoting no modifier
     */
    private final static int nullModifier = 0;

    /**
     * Constant for '+' modifier
     */
    private final static int plusModifier = 1;

    /**
     * Constant for '*' modifier
     */
    private final static int starModifier = 2;

    /**
     * Default constructor
     */
    VersionMatcher()
    {
    }

    /**
     * Returns true if the specified parameter versions match, otherwise returns false. [Give full rules here].
     *
     * @param req the required version
     * @param cap the capability version
     * @return true if the specified versions (req and cap) match
     * @throws InvalidVersionFormatException if the specified parameters contain an invalid version format
     */
    boolean matchVersion( String req, String cap )
        throws InvalidVersionFormatException
    {
        String[] requirement = tokenizeVersion( req );
        String[] capability = tokenizeVersion( cap );

        int capSize = capability.length;
        int reqSize = requirement.length;

        int reqModifier = getModifier( requirement );
        if ( reqModifier == plusModifier )
        {
            requirement[reqSize - 1] = requirement[reqSize - 1].replace( '+', ' ' ).trim();
        }
        else if ( reqModifier == starModifier )
        {
            requirement[reqSize - 1] = requirement[reqSize - 1].replace( '*', ' ' ).trim();
        }

        if ( reqSize < capSize && reqModifier != starModifier )
        {
            requirement = padArray( requirement, capSize );
        }
        else if ( capSize < reqSize )
        {
            capability = padArray( capability, reqSize );
        }

        switch ( reqModifier )
        {
            case nullModifier:
                return testExactMatch( requirement, capability );
            case plusModifier:
                return testGreaterThanMatch( requirement, capability );
            case starModifier:
                return testPrefixMatch( requirement, capability );
            default:
                return false;
        }
    }

    /**
     * Returns the maximum version of the given set of versions.
     *
     * @param versions a set of versions from which to choose the maximum version
     * @return the maximum version from the specified set of versions.
     * @throws InvalidVersionFormatException if the format of one or more of the versions is invalid
     */
    String getMaxVersion( Set<String> versions )
        throws InvalidVersionFormatException
    {
        if ( versions.isEmpty() )
        {
            return null;
        }
        Iterator i = versions.iterator();
        String maxVersion = (String) i.next();
        while ( i.hasNext() )
        {
            String testValue = (String) i.next();
            if ( isGreaterThan(maxVersion, testValue ) )
            {
                maxVersion = testValue;
            }
        }
        return maxVersion;
    }

    String getMinVersion( Set<String> versions )
        throws InvalidVersionFormatException
    {
        if ( versions.isEmpty() )
        {
            return null;
        }
        Iterator i = versions.iterator();
        String minVersion = (String) i.next();
        while ( i.hasNext() )
        {
            String testValue = (String) i.next();
            if ( isGreaterThan( testValue, minVersion ) )
            {
                minVersion = testValue;
            }
        }
        return minVersion;
    }

    /**
     * Returns true if v > v1, otherwise returns false.
     *
     * @param v     the first value to compare
     * @param v1    the second value to compare
     * @return true if v > v1, otherwise returns false
     */
    private boolean isGreaterThan( String v, String v1 )
        throws InvalidVersionFormatException
    {
        String[] requirement = tokenizeVersion( v );
        String[] capability = tokenizeVersion( v1 );

        int capSize = capability.length;
        int reqSize = requirement.length;
        if ( reqSize < capSize )
        {
            requirement = padArray( requirement, capSize );
        }
        else if ( capSize < reqSize )
        {
            capability = padArray( capability, reqSize );
        }

        return testGreaterThanMatch( requirement, capability );
    }

    /**
     * Returns an array padded with zeros. This is needed because one version may contain, say 1.2, while another version may
     * be 1.2.8. We need to add the implied 0 to read 1.2.0 so that the versions can be compared.
     *
     * @param value a string array without padded values
     * @param size  the size that the value array needs to be expanded
     * @return a string array with padded values
     */
    private String[] padArray( String[] value, int size )
    {
        int valueSize = value.length;
        int padSize = Math.abs( valueSize - size );

        String[] newValue = new String[size];

        System.arraycopy( value, 0, newValue, 0, valueSize );
        for ( int i = 0; i < padSize; i++ )
        {
            newValue[i + valueSize] = "0";
        }
        return newValue;
    }

    /**
     * Returns an int denoting a modifier (+, *) within the version. A value of 0 means that there is no modifier, a
     * value of 1 means that there is a + modifier and a value of 2 means that there is a * modifier.
     *
     * @param value a tokenized string array of the version
     * @return an int denoting a modifier within the version
     */
    private int getModifier( String[] value )
    {
        String lastValue = value[value.length - 1].trim();
        char lastChar = lastValue.charAt( lastValue.length() - 1 );
        if ( lastChar == '+' )
        {
            return plusModifier;
        }
        else if ( lastChar == '*' )
        {
            return starModifier;
        }
        else
        {
            return nullModifier;
        }
    }

    /**
     * Returns true if the requirement parameter exactly matches (each array value is the same) the capability.
     *
     * @param requirement   the requirement to match
     * @param capability    the capability to match
     * @return true if the requirement parameter exactly matches (each array value is the same) the capability
     */
    private boolean testExactMatch( String[] requirement, String[] capability )
    {
        int reqSize = requirement.length;
        if ( reqSize != capability.length )
        {
            return false;
        }

        for ( int i = 0; i < reqSize; i++ )
        {
            if ( !requirement[i].equals( capability[i] ) )
            {
                return false;
            }
        }
        return true;
    }

    private boolean testGreaterThanMatch( String[] requirement, String[] capability )
    {
        int reqSize = requirement.length;
        for ( int i = 0; i < reqSize; i++ )
        {
            if ( isNumber( requirement[i] ) && isNumber( capability[i] ) )
            {
                try
                {
                    int compare = new Integer( capability[i] ).compareTo( new Integer( requirement[i] ) );
                    if ( compare < 0 )
                    {
                        return false;
                    }
                    if ( compare > 0 )
                    {
                        return true;
                    }
                }
                catch ( NumberFormatException e )
                {
                    //this should never happen: already done check
                }
            }
            else
            {
                for ( int j = 0; j < reqSize - 1; j++ )
                {
                    char req = requirement[i].charAt( j );
                    char cap = capability[i].charAt( j );
                    if ( req < cap )
                    {
                        return true;
                    }
                    if ( req > cap )
                    {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    /**
     * Returns true if the specified number parameter is an integer, otherwise returns false.
     *
     * @param number the number to test for an integer format
     * @return true if the specified number parameter is an integer, otherwise returns false
     */
    private boolean isNumber( String number )
    {
        try
        {
            new Integer( number );
            return true;
        }
        catch ( NumberFormatException e )
        {
            return false;
        }
    }

    private boolean testPrefixMatch( String[] requirement, String[] capability )
    {
        int reqSize = requirement.length;
        for ( int i = 0; i < reqSize; i++ )
        {
            if ( !requirement[i].equals( capability[i] ) )
            {
                return false;
            }
        }
        return true;
    }

    /**
     * Returns a tokenized string array of the version based on the following standard version delimiters: '.', '_', '-'.
     *
     * @param version the version to tokenize
     * @return a tokenized string array of the version based on the following standard version delimiters: '.', '_', '-'
     * @throws InvalidVersionFormatException if the version format is invalid
     */
    private String[] tokenizeVersion( String version )
        throws InvalidVersionFormatException
    {
        if ( !isVersionId( version ) )
        {
            throw new InvalidVersionFormatException( "Invalid Version Id: ID = " + version );
        }
        return version.split( "[._-]" );
    }

    /**
     * Returns true if the specified version is valid (\p{Alnum}[._-]]*[+*]?), otherwise returns false.
     *
     * @param version the version to test for validity
     * @return true if the specified version is valid (\p{Alnum}[._-]]*[+*]?), otherwise returns false
     */
    private boolean isVersionId( String version )
    {
        return ( version != null ) && versionIdMatch.matcher( version ).matches();
    }

}