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

   1 package org.apache.maven.archiva.repository.content;
   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 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  24 import org.apache.maven.archiva.configuration.LegacyArtifactPath;
  25 import org.apache.maven.archiva.model.ArtifactReference;
  26 import org.apache.maven.archiva.repository.layout.LayoutException;
  27
  28 import java.util.Collection;
  29 import java.util.Iterator;
  30
  31 /**
  32  * LegacyPathParser is a parser for maven 1 (legacy layout) paths to
  33  * ArtifactReference.
  34  *
  35  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  36  * @version $Id$
  37  * @plexus.component role="org.apache.maven.archiva.repository.content.PathParser"
  38  * role-hint="legacy"
  39  */
  40 public class LegacyPathParser
  41     implements PathParser
  42 {
  43     private static final String INVALID_ARTIFACT_PATH = "Invalid path to Artifact: ";
  44
  45     /**
  46      * @plexus.requirement
  47      */
  48     protected ArchivaConfiguration configuration;
  49
  50     /**
  51      * {@inheritDoc}
  52      *
  53      * @see org.apache.maven.archiva.repository.content.PathParser#toArtifactReference(java.lang.String)
  54      */
  55     public ArtifactReference toArtifactReference( String path )
  56         throws LayoutException
  57     {
  58         ArtifactReference artifact = new ArtifactReference();
  59
  60         // First, look if a custom resolution rule has been set for this artifact
  61         Collection legacy = configuration.getConfiguration().getLegacyArtifactPaths();
  62         for ( Iterator iterator = legacy.iterator(); iterator.hasNext(); )
  63         {
  64             LegacyArtifactPath legacyPath = (LegacyArtifactPath) iterator.next();
  65             if ( legacyPath.match( path ) )
  66             {
  67                             artifact.setGroupId( legacyPath.getGroupId() );
  68                             artifact.setArtifactId( legacyPath.getArtifactId() );
  69                             artifact.setClassifier( legacyPath.getClassifier() );
  70                             artifact.setVersion( legacyPath.getVersion() );
  71                             artifact.setType( legacyPath.getType() );
  72                 return artifact;
  73             }
  74         }
  75
  76         String normalizedPath = StringUtils.replace( path, "\\", "/" );
  77
  78         String pathParts[] = StringUtils.split( normalizedPath, '/' );
  79
  80         /* Always 3 parts. (Never more or less)
  81          *
  82          *   path = "commons-lang/jars/commons-lang-2.1.jar"
  83          *   path[0] = "commons-lang";          // The Group ID
  84          *   path[1] = "jars";                  // The Directory Type
  85          *   path[2] = "commons-lang-2.1.jar";  // The Filename.
  86          */
  87
  88         if ( pathParts.length != 3 )
  89         {
  90             // Illegal Path Parts Length.
  91             throw new LayoutException( INVALID_ARTIFACT_PATH
  92                     + "legacy paths should only have 3 parts [groupId]/[type]s/[artifactId]-[version].[type], found "
  93                     + pathParts.length + " instead." );
  94         }
  95
  96         // The Group ID.
  97         artifact.setGroupId( pathParts[0] );
  98
  99         // The Expected Type.
 100         String expectedType = pathParts[1];
 101
 102         // Sanity Check: expectedType should end in "s".
 103         if ( !expectedType.endsWith( "s" ) )
 104         {
 105             throw new LayoutException( INVALID_ARTIFACT_PATH
 106                     + "legacy paths should have an expected type ending in [s] in the second part of the path." );
 107         }
 108
 109         // The Filename.
 110         String filename = pathParts[2];
 111
 112         FilenameParser parser = new FilenameParser( filename );
 113
 114         artifact.setArtifactId( parser.nextNonVersion() );
 115
 116         // Sanity Check: does it have an artifact id?
 117         if ( StringUtils.isEmpty( artifact.getArtifactId() ) )
 118         {
 119             // Special Case: The filename might start with a version id (like "test-arch-1.0.jar").
 120             int idx = filename.indexOf( '-' );
 121             if ( idx > 0 )
 122             {
 123                 parser.reset();
 124                 // Take the first section regardless of content.
 125                 String artifactId = parser.next();
 126
 127                 // Is there anything more that is considered not a version id?
 128                 String moreArtifactId = parser.nextNonVersion();
 129                 if ( StringUtils.isNotBlank( moreArtifactId ) )
 130                 {
 131                     artifact.setArtifactId( artifactId + "-" + moreArtifactId );
 132                 }
 133                 else
 134                 {
 135                     artifact.setArtifactId( artifactId );
 136                 }
 137             }
 138
 139             // Sanity Check: still no artifact id?
 140             if ( StringUtils.isEmpty( artifact.getArtifactId() ) )
 141             {
 142                 throw new LayoutException( INVALID_ARTIFACT_PATH + "no artifact id present." );
 143             }
 144         }
 145
 146         artifact.setVersion( parser.remaining() );
 147
 148         // Sanity Check: does it have a version?
 149         if ( StringUtils.isEmpty( artifact.getVersion() ) )
 150         {
 151             // Special Case: use last section of artifactId as version.
 152             String artifactId = artifact.getArtifactId();
 153             int idx = artifactId.lastIndexOf( '-' );
 154             if ( idx > 0 )
 155             {
 156                 artifact.setVersion( artifactId.substring( idx + 1 ) );
 157                 artifact.setArtifactId( artifactId.substring( 0, idx ) );
 158             }
 159             else
 160             {
 161                 throw new LayoutException( INVALID_ARTIFACT_PATH + "no version found." );
 162             }
 163         }
 164
 165         String classifier = ArtifactClassifierMapping.getClassifier( expectedType );
 166         if ( classifier != null )
 167         {
 168             String version = artifact.getVersion();
 169             if ( ! version.endsWith( "-" + classifier ) )
 170             {
 171                 throw new LayoutException( INVALID_ARTIFACT_PATH + expectedType + " artifacts must use the classifier " + classifier );
 172             }
 173             version = version.substring( 0, version.length() - classifier.length() - 1 );
 174             artifact.setVersion( version );
 175             artifact.setClassifier( classifier );
 176         }
 177
 178         String extension = parser.getExtension();
 179
 180         // Set Type
 181         artifact.setType( ArtifactExtensionMapping.mapExtensionAndClassifierToType( classifier, extension ) );
 182
 183         // Sanity Check: does it have an extension?
 184         if ( StringUtils.isEmpty( artifact.getType() ) )
 185         {
 186             throw new LayoutException( INVALID_ARTIFACT_PATH + "no extension found." );
 187         }
 188
 189         // Special Case with Maven Plugins
 190         if ( StringUtils.equals( "jar", artifact.getType() ) && StringUtils.equals( "plugins", expectedType ) )
 191         {
 192             artifact.setType( ArtifactExtensionMapping.MAVEN_PLUGIN );
 193         }
 194         else
 195         {
 196             // Sanity Check: does extension match pathType on path?
 197             String trimPathType = expectedType.substring( 0, expectedType.length() - 1 );
 198
 199             String expectedExtension = ArtifactExtensionMapping.getExtension( trimPathType );
 200
 201             if ( !expectedExtension.equals( extension ) )
 202             {
 203                 throw new LayoutException( INVALID_ARTIFACT_PATH + "mismatch on extension [" + extension
 204                     + "] and layout specified type [" + expectedType + "] (which maps to extension: ["
 205                     + expectedExtension + "]) on path [" + path + "]" );
 206             }
 207         }
 208
 209         return artifact;
 210     }
 211 }