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

   1 package org.apache.maven.repository.discovery;
   2
   3 /*
   4  * Copyright 2005-2006 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.List;
  27 import java.util.StringTokenizer;
  28
  29 /**
  30  * Artifact discoverer for the new repository layout (Maven 2.0+).
  31  *
  32  * @author John Casey
  33  * @author Brett Porter
  34  */
  35 public class DefaultArtifactDiscoverer
  36     extends AbstractArtifactDiscoverer
  37 {
  38     private ArtifactFactory artifactFactory;
  39
  40     public List discoverArtifacts( File repositoryBase, String blacklistedPatterns, boolean convertSnapshots )
  41     {
  42         List artifacts = new ArrayList();
  43
  44         String[] artifactPaths = scanForArtifactPaths( repositoryBase, blacklistedPatterns );
  45
  46         for ( int i = 0; i < artifactPaths.length; i++ )
  47         {
  48             String path = artifactPaths[i];
  49
  50             Artifact artifact = buildArtifact( path );
  51
  52             if ( artifact != null )
  53             {
  54                 if ( convertSnapshots || !artifact.isSnapshot() )
  55                 {
  56                     artifacts.add( artifact );
  57                 }
  58             }
  59         }
  60
  61         return artifacts;
  62     }
  63
  64     private Artifact buildArtifact( String path )
  65     {
  66         Artifact result;
  67
  68         List pathParts = new ArrayList();
  69         StringTokenizer st = new StringTokenizer( path, "/\\" );
  70         while ( st.hasMoreTokens() )
  71         {
  72             pathParts.add( st.nextToken() );
  73         }
  74
  75         Collections.reverse( pathParts );
  76
  77         if ( pathParts.size() < 4 )
  78         {
  79             addKickedOutPath( path );
  80
  81             return null;
  82         }
  83
  84         // the actual artifact filename.
  85         String filename = (String) pathParts.remove( 0 );
  86
  87         // the next one is the version.
  88         String version = (String) pathParts.remove( 0 );
  89
  90         // the next one is the artifactId.
  91         String artifactId = (String) pathParts.remove( 0 );
  92
  93         // the remaining are the groupId.
  94         Collections.reverse( pathParts );
  95         String groupId = StringUtils.join( pathParts.iterator(), "." );
  96
  97         String remainingFilename = filename;
  98         if ( !remainingFilename.startsWith( artifactId + "-" ) )
  99         {
 100             addKickedOutPath( path );
 101
 102             return null;
 103         }
 104
 105         remainingFilename = remainingFilename.substring( artifactId.length() + 1 );
 106
 107         String classifier = null;
 108
 109         // TODO: use artifact handler, share with legacy discoverer
 110         String type;
 111         if ( remainingFilename.endsWith( ".tar.gz" ) )
 112         {
 113             type = "distribution-tgz";
 114             remainingFilename = remainingFilename.substring( 0, remainingFilename.length() - 7 );
 115         }
 116         else if ( remainingFilename.endsWith( ".zip" ) )
 117         {
 118             type = "distribution-zip";
 119             remainingFilename = remainingFilename.substring( 0, remainingFilename.length() - 4 );
 120         }
 121         else if ( remainingFilename.endsWith( "-sources.jar" ) )
 122         {
 123             type = "java-source";
 124             classifier = "sources";
 125             remainingFilename = remainingFilename.substring( 0, remainingFilename.length() - 12 );
 126         }
 127         else
 128         {
 129             int index = remainingFilename.lastIndexOf( "." );
 130             if ( index < 0 )
 131             {
 132                 addKickedOutPath( path );
 133
 134                 return null;
 135             }
 136
 137             type = remainingFilename.substring( index + 1 );
 138             remainingFilename = remainingFilename.substring( 0, index );
 139         }
 140
 141         if ( classifier == null )
 142         {
 143             result = artifactFactory.createArtifact( groupId, artifactId, version, Artifact.SCOPE_RUNTIME, type );
 144         }
 145         else
 146         {
 147             result = artifactFactory.createArtifactWithClassifier( groupId, artifactId, version, type, classifier );
 148         }
 149
 150         if ( result.isSnapshot() )
 151         {
 152             // version is XXX-SNAPSHOT, filename is XXX-yyyyMMdd.hhmmss-b
 153             int classifierIndex = remainingFilename.indexOf( '-', version.length() + 8 );
 154             if ( classifierIndex >= 0 )
 155             {
 156                 classifier = remainingFilename.substring( classifierIndex + 1 );
 157                 remainingFilename = remainingFilename.substring( 0, classifierIndex );
 158                 result = artifactFactory.createArtifactWithClassifier( groupId, artifactId, remainingFilename, type,
 159                                                                        classifier );
 160             }
 161             else
 162             {
 163                 result = artifactFactory.createArtifact( groupId, artifactId, remainingFilename, Artifact.SCOPE_RUNTIME,
 164                                                          type );
 165             }
 166
 167             // poor encapsulation requires we do this to populate base version
 168             if ( !result.isSnapshot() )
 169             {
 170                 addKickedOutPath( path );
 171
 172                 return null;
 173             }
 174             if ( !result.getBaseVersion().equals( version ) )
 175             {
 176                 addKickedOutPath( path );
 177
 178                 return null;
 179             }
 180         }
 181         else if ( !remainingFilename.startsWith( version ) )
 182         {
 183             addKickedOutPath( path );
 184
 185             return null;
 186         }
 187         else if ( !remainingFilename.equals( version ) )
 188         {
 189             if ( remainingFilename.charAt( version.length() ) != '-' )
 190             {
 191                 addKickedOutPath( path );
 192
 193                 return null;
 194             }
 195             classifier = remainingFilename.substring( version.length() + 1 );
 196             result = artifactFactory.createArtifactWithClassifier( groupId, artifactId, version, type, classifier );
 197         }
 198
 199         result.setFile( new File( path ) );
 200
 201         return result;
 202     }
 203 }