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