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.common.utils.VersionUtil;
  24 import org.apache.maven.archiva.model.ArtifactReference;
  25 import org.apache.maven.archiva.repository.layout.LayoutException;
  26
  27 /**
  28  * DefaultPathParser is a parser for maven 2 (default layout) paths to ArtifactReference.
  29  *
  30  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  31  * @version $Id$
  32  *
  33  * @plexus.component role="org.apache.maven.archiva.repository.content.DefaultPathParser"
  34  */
  35 public class DefaultPathParser
  36 {
  37     private static final String INVALID_ARTIFACT_PATH = "Invalid path to Artifact: ";
  38
  39     /**
  40      * Convert a path to an ArtifactReference.
  41      *
  42      * @param path
  43      * @return
  44      * @throws LayoutException
  45      */
  46     protected static ArtifactReference toArtifactReference( String path )
  47         throws LayoutException
  48     {
  49         if ( StringUtils.isBlank( path ) )
  50         {
  51             throw new LayoutException( "Unable to convert blank path." );
  52         }
  53
  54         ArtifactReference artifact = new ArtifactReference();
  55
  56         String normalizedPath = StringUtils.replace( path, "\\", "/" );
  57         String pathParts[] = StringUtils.split( normalizedPath, '/' );
  58
  59         /* Minimum parts.
  60          *
  61          *   path = "commons-lang/commons-lang/2.1/commons-lang-2.1.jar"
  62          *   path[0] = "commons-lang";        // The Group ID
  63          *   path[1] = "commons-lang";        // The Artifact ID
  64          *   path[2] = "2.1";                 // The Version
  65          *   path[3] = "commons-lang-2.1.jar" // The filename.
  66          */
  67
  68         if ( pathParts.length < 4 )
  69         {
  70             // Illegal Path Parts Length.
  71             throw new LayoutException( "Not enough parts to the path [" + path
  72                 + "] to construct an ArchivaArtifact from. (Requires at least 4 parts)" );
  73         }
  74
  75         // Maven 2.x path.
  76         int partCount = pathParts.length;
  77         int filenamePos = partCount - 1;
  78         int baseVersionPos = partCount - 2;
  79         int artifactIdPos = partCount - 3;
  80         int groupIdPos = partCount - 4;
  81
  82         // Second to last is the baseVersion (the directory version)
  83         String baseVersion = pathParts[baseVersionPos];
  84
  85         // Third to last is the artifact Id.
  86         artifact.setArtifactId( pathParts[artifactIdPos] );
  87
  88         // Remaining pieces are the groupId.
  89         for ( int i = 0; i <= groupIdPos; i++ )
  90         {
  91             if ( i == 0 )
  92             {
  93                 artifact.setGroupId( pathParts[i] );
  94             }
  95             else
  96             {
  97                 artifact.setGroupId( artifact.getGroupId() + "." + pathParts[i] );
  98             }
  99         }
 100
 101         try
 102         {
 103             // Last part is the filename
 104             String filename = pathParts[filenamePos];
 105
 106             // Now we need to parse the filename to get the artifact version Id.
 107             if ( StringUtils.isBlank( filename ) )
 108             {
 109                 throw new IllegalArgumentException( INVALID_ARTIFACT_PATH + "Unable to split blank filename." );
 110             }
 111
 112             FilenameParser parser = new FilenameParser( filename );
 113
 114             // Expect the filename to start with the artifactId.
 115             artifact.setArtifactId( parser.expect( artifact.getArtifactId() ) );
 116
 117             if ( artifact.getArtifactId() == null )
 118             {
 119                 throw new LayoutException( INVALID_ARTIFACT_PATH + "filename format is invalid, "
 120                     + "should start with artifactId as stated in path." );
 121             }
 122
 123             // Process the version.
 124             artifact.setVersion( parser.expect( baseVersion ) );
 125
 126             if ( artifact.getVersion() == null )
 127             {
 128                 // We working with a snapshot?
 129                 if ( VersionUtil.isSnapshot( baseVersion ) )
 130                 {
 131                     artifact.setVersion( parser.nextVersion() );
 132                     if ( !VersionUtil.isUniqueSnapshot( artifact.getVersion() ) )
 133                     {
 134                         throw new LayoutException( INVALID_ARTIFACT_PATH + "filename format is invalid,"
 135                             + "expected timestamp format in filename." );
 136                     }
 137                 }
 138                 else
 139                 {
 140                     throw new LayoutException( INVALID_ARTIFACT_PATH + "filename format is invalid, "
 141                         + "expected version as stated in path." );
 142                 }
 143             }
 144
 145             // Do we have a classifier?
 146             artifact.setClassifier( parser.remaining() );
 147
 148             // Set the type.
 149             artifact.setType( ArtifactExtensionMapping.guessTypeFromFilename( filename ) );
 150
 151             // Special case for maven plugins
 152             if ( StringUtils.equals( "jar", artifact.getType() ) &&
 153                  ArtifactExtensionMapping.isMavenPlugin( artifact.getArtifactId() ) )
 154             {
 155                 artifact.setType( ArtifactExtensionMapping.MAVEN_PLUGIN );
 156             }
 157         }
 158         catch ( LayoutException e )
 159         {
 160             throw e;
 161         }
 162
 163         // Sanity Checks.
 164
 165         // Do we have a snapshot version?
 166         if ( VersionUtil.isSnapshot( artifact.getVersion() ) )
 167         {
 168             // Rules are different for SNAPSHOTS
 169             if ( !VersionUtil.isGenericSnapshot( baseVersion ) )
 170             {
 171                 String filenameBaseVersion = VersionUtil.getBaseVersion( artifact.getVersion() );
 172                 throw new LayoutException( "Invalid snapshot artifact location, version directory should be "
 173                     + filenameBaseVersion );
 174             }
 175         }
 176         else
 177         {
 178             // Non SNAPSHOT rules.
 179             // Do we pass the simple test?
 180             if ( !StringUtils.equals( baseVersion, artifact.getVersion() ) )
 181             {
 182                 throw new LayoutException( "Invalid artifact: version declared in directory path does"
 183                     + " not match what was found in the artifact filename." );
 184             }
 185         }
 186
 187         return artifact;
 188     }
 189
 190 }