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]*)",
  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     private static final String VersionMegaPattern = StringUtils.join( versionPatterns, '|' );
  61
  62     public static final String SNAPSHOT = "SNAPSHOT";
  63
  64     public static final Pattern UNIQUE_SNAPSHOT_PATTERN = Pattern.compile( "^(.*)-([0-9]{8}\\.[0-9]{6})-([0-9]+)$" );
  65
  66     public static final Pattern TIMESTAMP_PATTERN = Pattern.compile( "^([0-9]{8})\\.([0-9]{6})$" );
  67
  68     public static final Pattern GENERIC_SNAPSHOT_PATTERN = Pattern.compile( "^(.*)-" + SNAPSHOT );
  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         Pattern pat = Pattern.compile( VersionMegaPattern, Pattern.CASE_INSENSITIVE );
  89         Matcher mat;
  90
  91         int countValidParts = 0;
  92
  93         for ( int i = 0; i < versionParts.length; i++ )
  94         {
  95             String part = versionParts[i];
  96             mat = pat.matcher( part );
  97
  98             if ( mat.matches() )
  99             {
 100                 countValidParts++;
 101             }
 102         }
 103
 104         /* Calculate version probability as true if 3/4's of the input string has pieces of
 105          * of known version identifier strings.
 106          */
 107         int threshold = (int) Math.floor( Math.max( (double) 1.0, (double) ( versionParts.length * 0.75 ) ) );
 108
 109         return ( countValidParts >= threshold );
 110     }
 111
 112     /**
 113      * <p>
 114      * Tests if the identifier is a known simple version keyword.
 115      * </p>
 116      *
 117      * <p>
 118      * This method is different from {@link #isVersion(String)} in that it tests the whole input string in
 119      * one go as a simple identifier. (eg "alpha", "1.0", "beta", "debug", "latest", "rc#", etc...)
 120      * </p>
 121      *
 122      * @param identifier the identifier to test.
 123      * @return true if the unknown string is likely a version string.
 124      */
 125     public static boolean isSimpleVersionKeyword( String identifier )
 126     {
 127         Pattern pat = Pattern.compile( VersionMegaPattern, Pattern.CASE_INSENSITIVE );
 128         Matcher mat = pat.matcher( identifier );
 129
 130         return mat.matches();
 131     }
 132
 133     public static boolean isSnapshot( String version )
 134     {
 135         Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( version );
 136         if ( m.matches() )
 137         {
 138             return true;
 139         }
 140         else
 141         {
 142             return version.endsWith( SNAPSHOT );
 143         }
 144     }
 145
 146     public static String getBaseVersion( String version )
 147     {
 148         Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( version );
 149         if ( m.matches() )
 150         {
 151             return m.group( 1 ) + "-" + SNAPSHOT;
 152         }
 153         else
 154         {
 155             return version;
 156         }
 157     }
 158
 159     /**
 160      * <p>
 161      * Get the release version of the snapshot version.
 162      * </p>
 163      *
 164      * <p>
 165      * If snapshot version is 1.0-SNAPSHOT, then release version would be 1.0
 166      * And if snapshot version is 1.0-20070113.163208-1.jar, then release version would still be 1.0
 167      * </p>
 168      *
 169      * @param snapshotVersion
 170      * @return
 171      */
 172     public static String getReleaseVersion( String snapshotVersion )
 173     {
 174         Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( snapshotVersion );
 175
 176         if( isGenericSnapshot( snapshotVersion ) )
 177         {
 178             m = GENERIC_SNAPSHOT_PATTERN.matcher( snapshotVersion );
 179         }
 180
 181         if ( m.matches() )
 182         {
 183             return m.group( 1 );
 184         }
 185         else
 186         {
 187             return snapshotVersion;
 188         }
 189     }
 190
 191     public static boolean isUniqueSnapshot( String version )
 192     {
 193         Matcher m = UNIQUE_SNAPSHOT_PATTERN.matcher( version );
 194         if( m.matches() )
 195         {
 196             return true;
 197         }
 198
 199         return false;
 200     }
 201
 202     public static boolean isGenericSnapshot( String version )
 203     {
 204         return version.endsWith( SNAPSHOT );
 205     }
 206 }