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

   1 package org.apache.maven.repository.discovery;
   2
   3 /*
   4  * Copyright 2001-2005 The Apache Software Foundation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 import org.apache.maven.artifact.Artifact;
  20 import org.apache.maven.artifact.factory.ArtifactFactory;
  21 import org.codehaus.plexus.util.StringUtils;
  22
  23 import java.io.File;
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.Iterator;
  27 import java.util.LinkedList;
  28 import java.util.List;
  29 import java.util.StringTokenizer;
  30
  31 /**
  32  * Artifact discoverer for the legacy repository layout (Maven 1.x).
  33  *
  34  * @author John Casey
  35  * @author Brett Porter
  36  */
  37 public class LegacyArtifactDiscoverer
  38     extends AbstractArtifactDiscoverer
  39 {
  40     private ArtifactFactory artifactFactory;
  41
  42     public List discoverArtifacts( File repositoryBase, String blacklistedPatterns, boolean includeSnapshots )
  43     {
  44         List artifacts = new ArrayList();
  45
  46         String[] artifactPaths = scanForArtifactPaths( repositoryBase, blacklistedPatterns );
  47
  48         for ( int i = 0; i < artifactPaths.length; i++ )
  49         {
  50             String path = artifactPaths[i];
  51
  52             Artifact artifact = buildArtifact( path );
  53             if ( artifact != null )
  54             {
  55                 if ( includeSnapshots || !artifact.isSnapshot() )
  56                 {
  57                     artifacts.add( artifact );
  58                 }
  59             }
  60         }
  61
  62         return artifacts;
  63     }
  64
  65     private Artifact buildArtifact( String path )
  66     {
  67         StringTokenizer tokens = new StringTokenizer( path, "/\\" );
  68
  69         int numberOfTokens = tokens.countTokens();
  70
  71         if ( numberOfTokens != 3 )
  72         {
  73             addKickedOutPath( path );
  74
  75             return null;
  76         }
  77
  78         String groupId = tokens.nextToken();
  79
  80         String type = tokens.nextToken();
  81
  82         if ( type.endsWith( "s" ) )
  83         {
  84             type = type.substring( 0, type.length() - 1 );
  85         }
  86
  87         // contains artifactId, version, classifier, and extension.
  88         String avceGlob = tokens.nextToken();
  89
  90         LinkedList avceTokenList = new LinkedList();
  91
  92         StringTokenizer avceTokenizer = new StringTokenizer( avceGlob, "-" );
  93         while ( avceTokenizer.hasMoreTokens() )
  94         {
  95             avceTokenList.addLast( avceTokenizer.nextToken() );
  96         }
  97
  98         String lastAvceToken = (String) avceTokenList.removeLast();
  99
 100         if ( lastAvceToken.endsWith( ".tar.gz" ) )
 101         {
 102             type = "distribution-tgz";
 103
 104             lastAvceToken = lastAvceToken.substring( 0, lastAvceToken.length() - ".tar.gz".length() );
 105
 106             avceTokenList.addLast( lastAvceToken );
 107         }
 108         else if ( lastAvceToken.endsWith( "sources.jar" ) )
 109         {
 110             type = "java-source";
 111
 112             lastAvceToken = lastAvceToken.substring( 0, lastAvceToken.length() - ".jar".length() );
 113
 114             avceTokenList.addLast( lastAvceToken );
 115         }
 116         else if ( lastAvceToken.endsWith( ".zip" ) )
 117         {
 118             type = "distribution-zip";
 119
 120             lastAvceToken = lastAvceToken.substring( 0, lastAvceToken.length() - ".zip".length() );
 121
 122             avceTokenList.addLast( lastAvceToken );
 123         }
 124         else
 125         {
 126             int extPos = lastAvceToken.lastIndexOf( '.' );
 127
 128             if ( extPos > 0 )
 129             {
 130                 String ext = lastAvceToken.substring( extPos + 1 );
 131                 if ( type.equals( ext ) )
 132                 {
 133                     lastAvceToken = lastAvceToken.substring( 0, extPos );
 134
 135                     avceTokenList.addLast( lastAvceToken );
 136                 }
 137                 else
 138                 {
 139                     addKickedOutPath( path );
 140
 141                     return null;
 142                 }
 143             }
 144         }
 145
 146         // TODO: this is obscene - surely a better way?
 147         String validVersionParts = "([Dd][Ee][Vv][_.0-9]*)|" + "([Ss][Nn][Aa][Pp][Ss][Hh][Oo][Tt])|" +
 148             "([0-9][_.0-9a-zA-Z]*)|" + "([Gg]?[_.0-9ab]*([Pp][Rr][Ee]|[Rr][Cc]|[Gg]|[Mm])[_.0-9]*)|" +
 149             "([Aa][Ll][Pp][Hh][Aa][_.0-9]*)|" + "([Bb][Ee][Tt][Aa][_.0-9]*)|" + "([Rr][Cc][_.0-9]*)|" +
 150             "([Tt][Ee][Ss][Tt][_.0-9]*)|" + "([Dd][Ee][Bb][Uu][Gg][_.0-9]*)|" +
 151             "([Uu][Nn][Oo][Ff][Ff][Ii][Cc][Ii][Aa][Ll][_.0-9]*)|" + "([Cc][Uu][Rr][Rr][Ee][Nn][Tt])|" +
 152             "([Ll][Aa][Tt][Ee][Ss][Tt])|" + "([Ff][Cc][Ss])|" + "([Rr][Ee][Ll][Ee][Aa][Ss][Ee][_.0-9]*)|" +
 153             "([Nn][Ii][Gg][Hh][Tt][Ll][Yy])|" + "([AaBb][_.0-9]*)";
 154
 155         // let's discover the version, and whatever's leftover will be either
 156         // a classifier, or part of the artifactId, depending on position.
 157         // Since version is at the end, we have to move in from the back.
 158         Collections.reverse( avceTokenList );
 159
 160         StringBuffer classifierBuffer = new StringBuffer();
 161         StringBuffer versionBuffer = new StringBuffer();
 162
 163         boolean firstVersionTokenEncountered = false;
 164         boolean firstToken = true;
 165
 166         int tokensIterated = 0;
 167         for ( Iterator it = avceTokenList.iterator(); it.hasNext(); )
 168         {
 169             String token = (String) it.next();
 170
 171             boolean tokenIsVersionPart = token.matches( validVersionParts );
 172
 173             StringBuffer bufferToUpdate;
 174
 175             // NOTE: logic in code is reversed, since we're peeling off the back
 176             // Any token after the last versionPart will be in the classifier.
 177             // Any token UP TO first non-versionPart is part of the version.
 178             if ( !tokenIsVersionPart )
 179             {
 180                 if ( firstVersionTokenEncountered )
 181                 {
 182                     break;
 183                 }
 184                 else
 185                 {
 186                     bufferToUpdate = classifierBuffer;
 187                 }
 188             }
 189             else
 190             {
 191                 firstVersionTokenEncountered = true;
 192
 193                 bufferToUpdate = versionBuffer;
 194             }
 195
 196             if ( firstToken )
 197             {
 198                 firstToken = false;
 199             }
 200             else
 201             {
 202                 bufferToUpdate.insert( 0, '-' );
 203             }
 204
 205             bufferToUpdate.insert( 0, token );
 206
 207             tokensIterated++;
 208         }
 209
 210         getLogger().debug( "After parsing loop, state of buffers:\no  Version Buffer: \'" + versionBuffer +
 211             "\'\no  Classifier Buffer: \'" + classifierBuffer + "\'\no Number of Tokens Iterated: " + tokensIterated );
 212
 213         // Now, restore the proper ordering so we can build the artifactId.
 214         Collections.reverse( avceTokenList );
 215
 216         getLogger().debug(
 217             "Before repairing bad version and/or cleaning up used tokens, avce token list is:\n" + avceTokenList );
 218
 219         // if we didn't find a version, then punt. Use the last token
 220         // as the version, and set the classifier empty.
 221         if ( versionBuffer.length() < 1 )
 222         {
 223             if ( avceTokenList.size() > 1 )
 224             {
 225                 int lastIdx = avceTokenList.size() - 1;
 226
 227                 versionBuffer.append( avceTokenList.get( lastIdx ) );
 228                 avceTokenList.remove( lastIdx );
 229             }
 230             else
 231             {
 232                 getLogger().debug( "Cannot parse version from artifact path: \'" + path + "\'." );
 233                 getLogger().debug(
 234                     "artifact-version-classifier-extension remaining tokens is: \'" + avceTokenList + "\'" );
 235             }
 236
 237             classifierBuffer.setLength( 0 );
 238         }
 239         else
 240         {
 241             getLogger().debug( "Removing " + tokensIterated + " tokens from avce token list." );
 242
 243             // if everything is kosher, then pop off all the classifier and
 244             // version tokens, leaving the naked artifact id in the list.
 245             avceTokenList = new LinkedList( avceTokenList.subList( 0, avceTokenList.size() - tokensIterated ) );
 246         }
 247
 248         getLogger().debug( "Now, remainder of avce token list is:\n" + avceTokenList );
 249
 250         StringBuffer artifactIdBuffer = new StringBuffer();
 251
 252         firstToken = true;
 253         for ( Iterator it = avceTokenList.iterator(); it.hasNext(); )
 254         {
 255             String token = (String) it.next();
 256
 257             if ( firstToken )
 258             {
 259                 firstToken = false;
 260             }
 261             else
 262             {
 263                 artifactIdBuffer.append( '-' );
 264             }
 265
 266             artifactIdBuffer.append( token );
 267         }
 268
 269         String artifactId = artifactIdBuffer.toString();
 270
 271         int lastVersionCharIdx = versionBuffer.length() - 1;
 272         if ( lastVersionCharIdx > -1 && versionBuffer.charAt( lastVersionCharIdx ) == '-' )
 273         {
 274             versionBuffer.setLength( lastVersionCharIdx );
 275         }
 276
 277         String version = versionBuffer.toString();
 278
 279         if ( version.length() < 1 )
 280         {
 281             version = null;
 282         }
 283
 284         getLogger().debug( "Extracted artifact information from path:\n" + "groupId: \'" + groupId + "\'\n" +
 285             "artifactId: \'" + artifactId + "\'\n" + "type: \'" + type + "\'\n" + "version: \'" + version + "\'\n" +
 286             "classifier: \'" + classifierBuffer + "\'" );
 287
 288         Artifact result = null;
 289
 290         if ( classifierBuffer.length() > 0 )
 291         {
 292             getLogger().debug( "Creating artifact with classifier." );
 293
 294             result = artifactFactory.createArtifactWithClassifier( groupId, artifactId, version, type,
 295                                                                    classifierBuffer.toString() );
 296         }
 297         else
 298         {
 299             if ( StringUtils.isNotEmpty( groupId ) && StringUtils.isNotEmpty( artifactId ) &&
 300                 StringUtils.isNotEmpty( version ) && StringUtils.isNotEmpty( type ) )
 301             {
 302                 result = artifactFactory.createArtifact( groupId, artifactId, version, Artifact.SCOPE_RUNTIME, type );
 303             }
 304         }
 305
 306         result.setFile( new File( path ) );
 307
 308         return result;
 309     }
 310
 311 }