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