source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.archiva.common.utils;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.commons.lang.StringUtils;
  23
  24 import java.util.regex.Matcher;
  25 import java.util.regex.Pattern;
  26
  27 /**
  28  * Version utility methods.
  29  *
  30  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  31  * @version $Id$
  32  */
  33 public class VersionUtil
  34 {
  35     /**
  36      * These are the version patterns found in the filenames of the various artifact's versions IDs.
  37      * These patterns are all tackling lowercase version IDs.
  38      */
  39     private static final String versionPatterns[] = new String[] {
  40         "([0-9][_.0-9a-z]*)",
  41         "(snapshot)",
  42         "(g?[_.0-9ab]*(pre|rc|g|m)[_.0-9]*)",
  43         "(dev[_.0-9]*)",
  44         "(alpha[_.0-9]*)",
  45         "(beta[_.0-9]*)",
  46         "(rc[_.0-9]*)",
  47 //        "(test[_.0-9]*)", -- omitted for MRM-681, can be reinstated as part of MRM-712
  48         "(debug[_.0-9]*)",
  49         "(unofficial[_.0-9]*)",
  50         "(current)",
  51         "(latest)",
  52         "(fcs)",
  53         "(release[_.0-9]*)",
  54         "(nightly)",
  55         "(final)",
  56         "(incubating)",
  57         "(incubator)",
  58         "([ab][_.0-9]+)" };
  59
  60     public static final String SNAPSHOT = "SNAPSHOT";
  61
  62     public static final Pattern UNIQUE_SNAPSHOT_PATTERN = Pattern.compile( "^(.*)-([0-9]{8}\\.[0-9]{6})-([0-9]+)$" );
  63
  64     public static final Pattern TIMESTAMP_PATTERN = Pattern.compile( "^([0-9]{8})\\.([0-9]{6})$" );
  65
  66     public static final Pattern GENERIC_SNAPSHOT_PATTERN = Pattern.compile( "^(.*)-" + SNAPSHOT );
  67
  68     private static final Pattern VERSION_MEGA_PATTERN = Pattern.compile( StringUtils.join( versionPatterns, '|' ), Pattern.CASE_INSENSITIVE );
  69
  70     /**
  71      * <p>
  72      * Tests if the unknown string contains elements that identify it as a version string (or not).
  73      * </p>
  74      *
  75      * <p>
  76      * The algorithm tests each part of the string that is delimited by a '-' (dash) character.
  77      * If 75% or more of the sections are identified as 'version' strings, the result is
  78      * determined to be of a high probability to be version identifier string.
  79      * </p>
  80      *
  81      * @param unknown the unknown string to test.
  82      * @return true if the unknown string is likely a version string.
  83      */
  84     public static boolean isVersion( String unknown )
  85     {
  86         String versionParts[] = StringUtils.split( unknown, '-' );
  87
  88         Matcher mat;
  89
  90         int countValidParts = 0;
  91
  92         for ( int i = 0; i < versionParts.length; i++ )
  93         {
  94             String part = versionParts[i];
  95             mat = VERSION_MEGA_PATTERN.matcher( part );
  96
  97             if ( mat.matches() )
  98             {
  99                 countValidParts++;
 100             }
 101         }
 102
 103         /* Calculate version probability as true if 3/4's of the input string has pieces of
 104          * of known version identifier strings.
 105          */
 106         int threshold = (int) Math.floor( Math.max( (double) 1.0, (double) ( versionParts.length * 0.75 ) ) );
 107
 108         return ( countValidParts >= threshold );
 109     }
 110
 111     /**
 112      * <p>
 113      * Tests if the identifier is a known simple version keyword.
 114      * </p>
 115      *
 116      * <p>
 117      * This method is different from {@link #isVersion(String)} in that it tests the whole input string in
 118      * one go as a simple identifier. (eg "alpha", "1.0", "beta", "debug", "latest", "rc#", etc...)
 119      * </p>
 120      *
 121      * @param identifier the identifier to test.
 122      * @return true if the unknown string is likely a version string.
 123      */
 124     public static boolean isSimpleVersionKeyword( String identifier )
 125     {
 126         Matcher mat = VERSION_MEGA_PATTERN.matcher( identifier );
 127
 128         return mat.matches();
 129     }
 130
 131     public static boolean isSnapshot( String version )
 132     {
 133         Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( version );
 134         if ( m.matches() )
 135         {
 136             return true;
 137         }
 138         else
 139         {
 140             return version.endsWith( SNAPSHOT );
 141         }
 142     }
 143
 144     public static String getBaseVersion( String version )
 145     {
 146         Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( version );
 147         if ( m.matches() )
 148         {
 149             return m.group( 1 ) + "-" + SNAPSHOT;
 150         }
 151         else
 152         {
 153             return version;
 154         }
 155     }
 156
 157     /**
 158      * <p>
 159      * Get the release version of the snapshot version.
 160      * </p>
 161      *
 162      * <p>
 163      * If snapshot version is 1.0-SNAPSHOT, then release version would be 1.0
 164      * And if snapshot version is 1.0-20070113.163208-1.jar, then release version would still be 1.0
 165      * </p>
 166      *
 167      * @param snapshotVersion
 168      * @return
 169      */
 170     public static String getReleaseVersion( String snapshotVersion )
 171     {
 172         Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( snapshotVersion );
 173
 174         if( isGenericSnapshot( snapshotVersion ) )
 175         {
 176             m = GENERIC_SNAPSHOT_PATTERN.matcher( snapshotVersion );
 177         }
 178
 179         if ( m.matches() )
 180         {
 181             return m.group( 1 );
 182         }
 183         else
 184         {
 185             return snapshotVersion;
 186         }
 187     }
 188
 189     public static boolean isUniqueSnapshot( String version )
 190     {
 191         Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( version );
 192         if( m.matches() )
 193         {
 194             return true;
 195         }
 196
 197         return false;
 198     }
 199
 200     public static boolean isGenericSnapshot( String version )
 201     {
 202         return version.endsWith( SNAPSHOT );
 203     }
 204 }