Coverage Report

Coverage Report - org.apache.maven.project.artifact.MavenMetadataSource

Classes in this File

Line Coverage

Branch Coverage

Complexity

MavenMetadataSource

0/164

0/96

8.429

 package org.apache.maven.project.artifact;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.factory.ArtifactFactory;
 import org.apache.maven.artifact.metadata.ArtifactMetadataRetrievalException;
 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
 import org.apache.maven.artifact.metadata.ResolutionGroup;
 import org.apache.maven.artifact.repository.ArtifactRepository;
 import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
 import org.apache.maven.artifact.repository.metadata.Metadata;
 import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
 import org.apache.maven.artifact.repository.metadata.RepositoryMetadataManager;
 import org.apache.maven.artifact.repository.metadata.RepositoryMetadataResolutionException;
 import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
 import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter;
 import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
 import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
 import org.apache.maven.artifact.versioning.VersionRange;
 import org.apache.maven.model.Dependency;
 import org.apache.maven.model.DistributionManagement;
 import org.apache.maven.model.Exclusion;
 import org.apache.maven.model.Relocation;
 import org.apache.maven.project.DefaultProjectBuilderConfiguration;
 import org.apache.maven.project.InvalidProjectModelException;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.project.MavenProjectBuilder;
 import org.apache.maven.project.ProjectBuildingException;
 import org.apache.maven.project.validation.ModelValidationResult;
 import org.codehaus.plexus.logging.AbstractLogEnabled;
 import org.codehaus.plexus.util.StringUtils;
 
 import java.io.File;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
 /**
  * @author <a href="mailto:jason@maven.org">Jason van Zyl</a>
  * @author <a href="mailto:brett@apache.org">Brett Porter</a>
  * @version $Id: MavenMetadataSource.java 736543 2009-01-22 03:33:16Z jdcasey $
  */
 public class MavenMetadataSource
     extends AbstractLogEnabled
     implements ArtifactMetadataSource
 {
     public static final String ROLE_HINT = "maven";
 
     private MavenProjectBuilder mavenProjectBuilder;
 
     private ArtifactFactory artifactFactory;
 
     private RepositoryMetadataManager repositoryMetadataManager;
 
     // lazily instantiated and cached.
     private MavenProject superProject;
 
     /**
      * Resolve all relocations in the POM for this artifact, and return the new artifact coordinate.
      */
     public Artifact retrieveRelocatedArtifact( Artifact artifact, ArtifactRepository localRepository, List remoteRepositories )
         throws ArtifactMetadataRetrievalException
     {
         if ( artifact instanceof ActiveProjectArtifact )
         {
             return artifact;
         }
 
         MavenProject project = retrieveRelocatedProject( artifact, localRepository, remoteRepositories );
 
         if ( project == null || getRelocationKey( artifact ).equals( getRelocationKey( project.getArtifact() ) ) )
         {
             return artifact;
         }
 
         
         // NOTE: Using artifact information here, since some POMs are deployed 
         // to central with one version in the filename, but another in the <version> string!
         // Case in point: org.apache.ws.commons:XmlSchema:1.1:pom.
         //
         // Since relocation triggers a reconfiguration of the artifact's information
         // in retrieveRelocatedProject(..), this is safe to do.
         Artifact result = null;
         if ( artifact.getClassifier() != null )
         {
             result = artifactFactory.createArtifactWithClassifier( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(), artifact.getType(), artifact.getClassifier() );
         }
         else
         {
             result = artifactFactory.createArtifact( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(), artifact.getScope(), artifact.getType() );
         }
 
         result.setResolved( artifact.isResolved() );
         result.setFile( artifact.getFile() );
 
         result.setScope( artifact.getScope() );
         result.setArtifactHandler( artifact.getArtifactHandler() );
         result.setDependencyFilter( artifact.getDependencyFilter() );
         result.setDependencyTrail( artifact.getDependencyTrail() );
         result.setOptional( artifact.isOptional() );
         result.setRelease( artifact.isRelease() );
 
         return result;
     }
 
     private String getRelocationKey( Artifact artifact )
     {
         return artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion();
     }
 
     private MavenProject retrieveRelocatedProject( Artifact artifact, ArtifactRepository localRepository, List remoteRepositories )
         throws ArtifactMetadataRetrievalException
     {
         MavenProject project = null;
 
         Artifact pomArtifact;
         boolean done = false;
         do
         {
             // TODO: can we just modify the original?
             pomArtifact = artifactFactory.createProjectArtifact( artifact.getGroupId(), artifact.getArtifactId(),
                                                                  artifact.getVersion(), artifact.getScope() );
 
             if ( Artifact.SCOPE_SYSTEM.equals( artifact.getScope() ) )
             {
                 done = true;
             }
             else
             {
                 try
                 {
                     project = mavenProjectBuilder.buildFromRepository( pomArtifact, remoteRepositories, localRepository,
                                                                        true );
                 }
                 catch ( InvalidProjectModelException e )
                 {
                     getLogger().warn( "POM for \'" + pomArtifact +
                         "\' is invalid. It will be ignored for artifact resolution. Reason: " + e.getMessage() );
 
                     if ( getLogger().isDebugEnabled() )
                     {
                         getLogger().debug( "Reason: " + e.getMessage() );
 
                         ModelValidationResult validationResult = e.getValidationResult();
 
                         if ( validationResult != null )
                         {
                             getLogger().debug( "\nValidation Errors:" );
                             for ( Iterator i = validationResult.getMessages().iterator(); i.hasNext(); )
                             {
                                 getLogger().debug( i.next().toString() );
                             }
                             getLogger().debug( "\n" );
                         }
                     }
 
                     project = null;
                 }
                 catch ( ProjectBuildingException e )
                 {
                     throw new ArtifactMetadataRetrievalException( "Unable to read the metadata file for artifact '" +
                         artifact.getDependencyConflictId() + "': " + e.getMessage(), e, artifact );
                 }
 
                 if ( project != null )
                 {
                     Relocation relocation = null;
 
                     DistributionManagement distMgmt = project.getDistributionManagement();
                     if ( distMgmt != null )
                     {
                         relocation = distMgmt.getRelocation();
 
                         artifact.setDownloadUrl( distMgmt.getDownloadUrl() );
                         pomArtifact.setDownloadUrl( distMgmt.getDownloadUrl() );
                     }
 
                     if ( relocation != null )
                     {
                         if ( relocation.getGroupId() != null )
                         {
                             artifact.setGroupId( relocation.getGroupId() );
                             project.setGroupId( relocation.getGroupId() );
                         }
                         if ( relocation.getArtifactId() != null )
                         {
                             artifact.setArtifactId( relocation.getArtifactId() );
                             project.setArtifactId( relocation.getArtifactId() );
                         }
                         if ( relocation.getVersion() != null )
                         {
                             //note: see MNG-3454. This causes a problem, but fixing it may break more.
                             artifact.setVersionRange( VersionRange.createFromVersion( relocation.getVersion() ) );
                             project.setVersion( relocation.getVersion() );
                         }
 
                         if ( artifact.getDependencyFilter() != null &&
                             !artifact.getDependencyFilter().include( artifact ) )
                         {
                             return null;
                         }
 
                         //MNG-2861: the artifact data has changed. If the available versions where previously retrieved,
                         //we need to update it. TODO: shouldn't the versions be merged across relocations?
                         List available = artifact.getAvailableVersions();
                         if ( available != null && !available.isEmpty() )
                         {
                             artifact.setAvailableVersions( retrieveAvailableVersions( artifact, localRepository,
                                                                                            remoteRepositories ) );
 
                         }
 
                         String message = "\n  This artifact has been relocated to " + artifact.getGroupId() + ":" +
                             artifact.getArtifactId() + ":" + artifact.getVersion() + ".\n";
 
                         if ( relocation.getMessage() != null )
                         {
                             message += "  " + relocation.getMessage() + "\n";
                         }
 
                         if ( artifact.getDependencyTrail() != null && artifact.getDependencyTrail().size() == 1 )
                         {
                             getLogger().warn( "While downloading " + pomArtifact.getGroupId() + ":" +
                                 pomArtifact.getArtifactId() + ":" + pomArtifact.getVersion() + message + "\n" );
                         }
                         else
                         {
                             getLogger().debug( "While downloading " + pomArtifact.getGroupId() + ":" +
                                 pomArtifact.getArtifactId() + ":" + pomArtifact.getVersion() + message + "\n" );
                         }
                     }
                     else
                     {
                         done = true;
                     }
                 }
                 else
                 {
                     done = true;
                 }
             }
         }
         while ( !done );
 
         return project;
     }
 
     /**
      * Retrieve the metadata for the project from the repository.
      * Uses the ProjectBuilder, to enable post-processing and inheritance calculation before retrieving the
      * associated artifacts.
      */
     public ResolutionGroup retrieve( Artifact artifact, ArtifactRepository localRepository, List remoteRepositories )
         throws ArtifactMetadataRetrievalException
     {
         MavenProject project = retrieveRelocatedProject( artifact, localRepository, remoteRepositories );
         Artifact pomArtifact;
         if ( project != null )
         {
             pomArtifact = project.getArtifact();
         }
         else
         {
             pomArtifact = artifactFactory.createProjectArtifact( artifact.getGroupId(),
                                                    artifact.getArtifactId(),
                                                    artifact.getVersion(),
                                                    artifact.getScope() );
         }
 
 
         // last ditch effort to try to get this set...
         if ( artifact.getDownloadUrl() == null && pomArtifact != null )
         {
             // TODO: this could come straight from the project, negating the need to set it in the project itself?
             artifact.setDownloadUrl( pomArtifact.getDownloadUrl() );
         }
 
         ResolutionGroup result;
 
         if ( project == null )
         {
             // if the project is null, we encountered an invalid model (read: m1 POM)
             // we'll just return an empty resolution group.
             // or used the inherited scope (should that be passed to the buildFromRepository method above?)
             result = new ResolutionGroup( pomArtifact, Collections.EMPTY_SET, Collections.EMPTY_LIST );
         }
         else
         {
             Set artifacts = Collections.EMPTY_SET;
             if ( !artifact.getArtifactHandler().isIncludesDependencies() )
             {
                 // TODO: we could possibly use p.getDependencyArtifacts instead of this call, but they haven't been filtered
                 // or used the inherited scope (should that be passed to the buildFromRepository method above?)
                 try
                 {
                     artifacts = project.createArtifacts( artifactFactory, artifact.getScope(),
                                                          artifact.getDependencyFilter() );
                 }
                 catch ( InvalidDependencyVersionException e )
                 {
                     throw new ArtifactMetadataRetrievalException( "Error in metadata for artifact '" +
                         artifact.getDependencyConflictId() + "': " + e.getMessage(), e );
                 }
             }
 
             List repositories = aggregateRepositoryLists( remoteRepositories, project.getRemoteArtifactRepositories() );
 
             result = new ResolutionGroup( pomArtifact, artifacts, repositories );
         }
 
         return result;
     }
 
     private List aggregateRepositoryLists( List remoteRepositories, List remoteArtifactRepositories )
         throws ArtifactMetadataRetrievalException
     {
         if ( superProject == null )
         {
             try
             {
                 superProject = mavenProjectBuilder.buildStandaloneSuperProject( new DefaultProjectBuilderConfiguration() );
             }
             catch ( ProjectBuildingException e )
             {
                 throw new ArtifactMetadataRetrievalException(
                     "Unable to parse the Maven built-in model: " + e.getMessage(), e );
             }
         }
 
         List repositories = new ArrayList();
 
         repositories.addAll( remoteRepositories );
 
         // ensure that these are defined
         for ( Iterator it = superProject.getRemoteArtifactRepositories().iterator(); it.hasNext(); )
         {
             ArtifactRepository superRepo = (ArtifactRepository) it.next();
 
             for ( Iterator aggregatedIterator = repositories.iterator(); aggregatedIterator.hasNext(); )
             {
                 ArtifactRepository repo = (ArtifactRepository) aggregatedIterator.next();
 
                 // if the repository exists in the list and was introduced by another POM's super-pom,
                 // remove it...the repository definitions from the super-POM should only be at the end of
                 // the list.
                 // if the repository has been redefined, leave it.
                 if ( repo.getId().equals( superRepo.getId() ) && repo.getUrl().equals( superRepo.getUrl() ) )
                 {
                     aggregatedIterator.remove();
                 }
             }
         }
 
         // this list should contain the super-POM repositories, so we don't have to explicitly add them back.
         for ( Iterator it = remoteArtifactRepositories.iterator(); it.hasNext(); )
         {
             ArtifactRepository repository = (ArtifactRepository) it.next();
 
             if ( !repositories.contains( repository ) )
             {
                 repositories.add( repository );
             }
         }
 
         return repositories;
     }
 
     /**
      * @todo desperately needs refactoring. It's just here because it's implementation is maven-project specific
      * @return {@link Set} &lt; {@link Artifact} >
      */
     public static Set createArtifacts( ArtifactFactory artifactFactory, List dependencies, String inheritedScope,
                                        ArtifactFilter dependencyFilter, MavenProject project )
         throws InvalidDependencyVersionException
     {
         Set projectArtifacts = new LinkedHashSet( dependencies.size() );
 
         for ( Iterator i = dependencies.iterator(); i.hasNext(); )
         {
             Dependency d = (Dependency) i.next();
 
             String scope = d.getScope();
 
             if ( StringUtils.isEmpty( scope ) )
             {
                 scope = Artifact.SCOPE_COMPILE;
 
                 d.setScope( scope );
             }
 
             VersionRange versionRange;
             try
             {
                 versionRange = VersionRange.createFromVersionSpec( d.getVersion() );
             }
             catch ( InvalidVersionSpecificationException e )
             {
                 throw new InvalidDependencyVersionException( "Unable to parse version '" + d.getVersion() +
                     "' for dependency '" + d.getManagementKey() + "': " + e.getMessage(), e );
             }
             Artifact artifact = artifactFactory.createDependencyArtifact( d.getGroupId(), d.getArtifactId(),
                                                                           versionRange, d.getType(), d.getClassifier(),
                                                                           scope, inheritedScope, d.isOptional() );
 
             if ( Artifact.SCOPE_SYSTEM.equals( scope ) )
             {
                 artifact.setFile( new File( d.getSystemPath() ) );
             }
 
             ArtifactFilter artifactFilter = dependencyFilter;
 
             // MNG-3769: It would be nice to be able to process relocations here, 
             // so we could have this filtering step apply to post-relocated dependencies.
             // HOWEVER, this would require a much more invasive POM resolution process
             // in order to look for relocations, which would make the early steps in 
             // a Maven build way too heavy.
             if ( artifact != null && ( artifactFilter == null || artifactFilter.include( artifact ) ) )
             {
                 if ( d.getExclusions() != null && !d.getExclusions().isEmpty() )
                 {
                     List exclusions = new ArrayList();
                     for ( Iterator j = d.getExclusions().iterator(); j.hasNext(); )
                     {
                         Exclusion e = (Exclusion) j.next();
                         exclusions.add( e.getGroupId() + ":" + e.getArtifactId() );
                     }
 
                     ArtifactFilter newFilter = new ExcludesArtifactFilter( exclusions );
 
                     if ( artifactFilter != null )
                     {
                         AndArtifactFilter filter = new AndArtifactFilter();
                         filter.add( artifactFilter );
                         filter.add( newFilter );
                         artifactFilter = filter;
                     }
                     else
                     {
                         artifactFilter = newFilter;
                     }
                 }
 
                 artifact.setDependencyFilter( artifactFilter );
 
                 if ( project != null )
                 {
                     artifact = project.replaceWithActiveArtifact( artifact );
                 }
 
                 projectArtifacts.add( artifact );
             }
         }
 
         return projectArtifacts;
     }
 
     public List retrieveAvailableVersions( Artifact artifact, ArtifactRepository localRepository,
                                            List remoteRepositories )
         throws ArtifactMetadataRetrievalException
     {
         RepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
         try
         {
             repositoryMetadataManager.resolve( metadata, remoteRepositories, localRepository );
         }
         catch ( RepositoryMetadataResolutionException e )
         {
             throw new ArtifactMetadataRetrievalException( e.getMessage(), e );
         }
 
         List versions;
         Metadata repoMetadata = metadata.getMetadata();
         if ( repoMetadata != null && repoMetadata.getVersioning() != null )
         {
             List metadataVersions = repoMetadata.getVersioning().getVersions();
             versions = new ArrayList( metadataVersions.size() );
             for ( Iterator i = metadataVersions.iterator(); i.hasNext(); )
             {
                 String version = (String) i.next();
                 versions.add( new DefaultArtifactVersion( version ) );
             }
         }
         else
         {
             versions = Collections.EMPTY_LIST;
         }
 
         return versions;
     }
 }

1		package org.apache.maven.project.artifact;
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.maven.artifact.Artifact;
23		import org.apache.maven.artifact.factory.ArtifactFactory;
24		import org.apache.maven.artifact.metadata.ArtifactMetadataRetrievalException;
25		import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
26		import org.apache.maven.artifact.metadata.ResolutionGroup;
27		import org.apache.maven.artifact.repository.ArtifactRepository;
28		import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
29		import org.apache.maven.artifact.repository.metadata.Metadata;
30		import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
31		import org.apache.maven.artifact.repository.metadata.RepositoryMetadataManager;
32		import org.apache.maven.artifact.repository.metadata.RepositoryMetadataResolutionException;
33		import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
34		import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
35		import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter;
36		import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
37		import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
38		import org.apache.maven.artifact.versioning.VersionRange;
39		import org.apache.maven.model.Dependency;
40		import org.apache.maven.model.DistributionManagement;
41		import org.apache.maven.model.Exclusion;
42		import org.apache.maven.model.Relocation;
43		import org.apache.maven.project.DefaultProjectBuilderConfiguration;
44		import org.apache.maven.project.InvalidProjectModelException;
45		import org.apache.maven.project.MavenProject;
46		import org.apache.maven.project.MavenProjectBuilder;
47		import org.apache.maven.project.ProjectBuildingException;
48		import org.apache.maven.project.validation.ModelValidationResult;
49		import org.codehaus.plexus.logging.AbstractLogEnabled;
50		import org.codehaus.plexus.util.StringUtils;
51
52		import java.io.File;
53		import java.util.ArrayList;
54		import java.util.Collections;
55		import java.util.Iterator;
56		import java.util.LinkedHashSet;
57		import java.util.List;
58		import java.util.Set;
59
60		/**
61		* @author <a href="mailto:jason@maven.org">Jason van Zyl</a>
62		* @author <a href="mailto:brett@apache.org">Brett Porter</a>
63		* @version $Id: MavenMetadataSource.java 736543 2009-01-22 03:33:16Z jdcasey $
64		*/
65	0	public class MavenMetadataSource
66		extends AbstractLogEnabled
67		implements ArtifactMetadataSource
68		{
69		public static final String ROLE_HINT = "maven";
70
71		private MavenProjectBuilder mavenProjectBuilder;
72
73		private ArtifactFactory artifactFactory;
74
75		private RepositoryMetadataManager repositoryMetadataManager;
76
77		// lazily instantiated and cached.
78		private MavenProject superProject;
79
80		/**
81		* Resolve all relocations in the POM for this artifact, and return the new artifact coordinate.
82		*/
83		public Artifact retrieveRelocatedArtifact( Artifact artifact, ArtifactRepository localRepository, List remoteRepositories )
84		throws ArtifactMetadataRetrievalException
85		{
86	0	if ( artifact instanceof ActiveProjectArtifact )
87		{
88	0	return artifact;
89		}
90
91	0	MavenProject project = retrieveRelocatedProject( artifact, localRepository, remoteRepositories );
92
93	0	if ( project == null \|\| getRelocationKey( artifact ).equals( getRelocationKey( project.getArtifact() ) ) )
94		{
95	0	return artifact;
96		}
97
98
99		// NOTE: Using artifact information here, since some POMs are deployed
100		// to central with one version in the filename, but another in the <version> string!
101		// Case in point: org.apache.ws.commons:XmlSchema:1.1:pom.
102		//
103		// Since relocation triggers a reconfiguration of the artifact's information
104		// in retrieveRelocatedProject(..), this is safe to do.
105	0	Artifact result = null;
106	0	if ( artifact.getClassifier() != null )
107		{
108	0	result = artifactFactory.createArtifactWithClassifier( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(), artifact.getType(), artifact.getClassifier() );
109		}
110		else
111		{
112	0	result = artifactFactory.createArtifact( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(), artifact.getScope(), artifact.getType() );
113		}
114
115	0	result.setResolved( artifact.isResolved() );
116	0	result.setFile( artifact.getFile() );
117
118	0	result.setScope( artifact.getScope() );
119	0	result.setArtifactHandler( artifact.getArtifactHandler() );
120	0	result.setDependencyFilter( artifact.getDependencyFilter() );
121	0	result.setDependencyTrail( artifact.getDependencyTrail() );
122	0	result.setOptional( artifact.isOptional() );
123	0	result.setRelease( artifact.isRelease() );
124
125	0	return result;
126		}
127
128		private String getRelocationKey( Artifact artifact )
129		{
130	0	return artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion();
131		}
132
133		private MavenProject retrieveRelocatedProject( Artifact artifact, ArtifactRepository localRepository, List remoteRepositories )
134		throws ArtifactMetadataRetrievalException
135		{
136	0	MavenProject project = null;
137
138		Artifact pomArtifact;
139	0	boolean done = false;
140		do
141		{
142		// TODO: can we just modify the original?
143	0	pomArtifact = artifactFactory.createProjectArtifact( artifact.getGroupId(), artifact.getArtifactId(),
144		artifact.getVersion(), artifact.getScope() );
145
146	0	if ( Artifact.SCOPE_SYSTEM.equals( artifact.getScope() ) )
147		{
148	0	done = true;
149		}
150		else
151		{
152		try
153		{
154	0	project = mavenProjectBuilder.buildFromRepository( pomArtifact, remoteRepositories, localRepository,
155		true );
156		}
157	0	catch ( InvalidProjectModelException e )
158		{
159	0	getLogger().warn( "POM for \'" + pomArtifact +
160		"\' is invalid. It will be ignored for artifact resolution. Reason: " + e.getMessage() );
161
162	0	if ( getLogger().isDebugEnabled() )
163		{
164	0	getLogger().debug( "Reason: " + e.getMessage() );
165
166	0	ModelValidationResult validationResult = e.getValidationResult();
167
168	0	if ( validationResult != null )
169		{
170	0	getLogger().debug( "\nValidation Errors:" );
171	0	for ( Iterator i = validationResult.getMessages().iterator(); i.hasNext(); )
172		{
173	0	getLogger().debug( i.next().toString() );
174		}
175	0	getLogger().debug( "\n" );
176		}
177		}
178
179	0	project = null;
180		}
181	0	catch ( ProjectBuildingException e )
182		{
183	0	throw new ArtifactMetadataRetrievalException( "Unable to read the metadata file for artifact '" +
184		artifact.getDependencyConflictId() + "': " + e.getMessage(), e, artifact );
185	0	}
186
187	0	if ( project != null )
188		{
189	0	Relocation relocation = null;
190
191	0	DistributionManagement distMgmt = project.getDistributionManagement();
192	0	if ( distMgmt != null )
193		{
194	0	relocation = distMgmt.getRelocation();
195
196	0	artifact.setDownloadUrl( distMgmt.getDownloadUrl() );
197	0	pomArtifact.setDownloadUrl( distMgmt.getDownloadUrl() );
198		}
199
200	0	if ( relocation != null )
201		{
202	0	if ( relocation.getGroupId() != null )
203		{
204	0	artifact.setGroupId( relocation.getGroupId() );
205	0	project.setGroupId( relocation.getGroupId() );
206		}
207	0	if ( relocation.getArtifactId() != null )
208		{
209	0	artifact.setArtifactId( relocation.getArtifactId() );
210	0	project.setArtifactId( relocation.getArtifactId() );
211		}
212	0	if ( relocation.getVersion() != null )
213		{
214		//note: see MNG-3454. This causes a problem, but fixing it may break more.
215	0	artifact.setVersionRange( VersionRange.createFromVersion( relocation.getVersion() ) );
216	0	project.setVersion( relocation.getVersion() );
217		}
218
219	0	if ( artifact.getDependencyFilter() != null &&
220		!artifact.getDependencyFilter().include( artifact ) )
221		{
222	0	return null;
223		}
224
225		//MNG-2861: the artifact data has changed. If the available versions where previously retrieved,
226		//we need to update it. TODO: shouldn't the versions be merged across relocations?
227	0	List available = artifact.getAvailableVersions();
228	0	if ( available != null && !available.isEmpty() )
229		{
230	0	artifact.setAvailableVersions( retrieveAvailableVersions( artifact, localRepository,
231		remoteRepositories ) );
232
233		}
234
235	0	String message = "\n This artifact has been relocated to " + artifact.getGroupId() + ":" +
236		artifact.getArtifactId() + ":" + artifact.getVersion() + ".\n";
237
238	0	if ( relocation.getMessage() != null )
239		{
240	0	message += " " + relocation.getMessage() + "\n";
241		}
242
243	0	if ( artifact.getDependencyTrail() != null && artifact.getDependencyTrail().size() == 1 )
244		{
245	0	getLogger().warn( "While downloading " + pomArtifact.getGroupId() + ":" +
246		pomArtifact.getArtifactId() + ":" + pomArtifact.getVersion() + message + "\n" );
247		}
248		else
249		{
250	0	getLogger().debug( "While downloading " + pomArtifact.getGroupId() + ":" +
251		pomArtifact.getArtifactId() + ":" + pomArtifact.getVersion() + message + "\n" );
252		}
253	0	}
254		else
255		{
256	0	done = true;
257		}
258	0	}
259		else
260		{
261	0	done = true;
262		}
263		}
264		}
265	0	while ( !done );
266
267	0	return project;
268		}
269
270		/**
271		* Retrieve the metadata for the project from the repository.
272		* Uses the ProjectBuilder, to enable post-processing and inheritance calculation before retrieving the
273		* associated artifacts.
274		*/
275		public ResolutionGroup retrieve( Artifact artifact, ArtifactRepository localRepository, List remoteRepositories )
276		throws ArtifactMetadataRetrievalException
277		{
278	0	MavenProject project = retrieveRelocatedProject( artifact, localRepository, remoteRepositories );
279		Artifact pomArtifact;
280	0	if ( project != null )
281		{
282	0	pomArtifact = project.getArtifact();
283		}
284		else
285		{
286	0	pomArtifact = artifactFactory.createProjectArtifact( artifact.getGroupId(),
287		artifact.getArtifactId(),
288		artifact.getVersion(),
289		artifact.getScope() );
290		}
291
292
293		// last ditch effort to try to get this set...
294	0	if ( artifact.getDownloadUrl() == null && pomArtifact != null )
295		{
296		// TODO: this could come straight from the project, negating the need to set it in the project itself?
297	0	artifact.setDownloadUrl( pomArtifact.getDownloadUrl() );
298		}
299
300		ResolutionGroup result;
301
302	0	if ( project == null )
303		{
304		// if the project is null, we encountered an invalid model (read: m1 POM)
305		// we'll just return an empty resolution group.
306		// or used the inherited scope (should that be passed to the buildFromRepository method above?)
307	0	result = new ResolutionGroup( pomArtifact, Collections.EMPTY_SET, Collections.EMPTY_LIST );
308		}
309		else
310		{
311	0	Set artifacts = Collections.EMPTY_SET;
312	0	if ( !artifact.getArtifactHandler().isIncludesDependencies() )
313		{
314		// TODO: we could possibly use p.getDependencyArtifacts instead of this call, but they haven't been filtered
315		// or used the inherited scope (should that be passed to the buildFromRepository method above?)
316		try
317		{
318	0	artifacts = project.createArtifacts( artifactFactory, artifact.getScope(),
319		artifact.getDependencyFilter() );
320		}
321	0	catch ( InvalidDependencyVersionException e )
322		{
323	0	throw new ArtifactMetadataRetrievalException( "Error in metadata for artifact '" +
324		artifact.getDependencyConflictId() + "': " + e.getMessage(), e );
325	0	}
326		}
327
328	0	List repositories = aggregateRepositoryLists( remoteRepositories, project.getRemoteArtifactRepositories() );
329
330	0	result = new ResolutionGroup( pomArtifact, artifacts, repositories );
331		}
332
333	0	return result;
334		}
335
336		private List aggregateRepositoryLists( List remoteRepositories, List remoteArtifactRepositories )
337		throws ArtifactMetadataRetrievalException
338		{
339	0	if ( superProject == null )
340		{
341		try
342		{
343	0	superProject = mavenProjectBuilder.buildStandaloneSuperProject( new DefaultProjectBuilderConfiguration() );
344		}
345	0	catch ( ProjectBuildingException e )
346		{
347	0	throw new ArtifactMetadataRetrievalException(
348		"Unable to parse the Maven built-in model: " + e.getMessage(), e );
349	0	}
350		}
351
352	0	List repositories = new ArrayList();
353
354	0	repositories.addAll( remoteRepositories );
355
356		// ensure that these are defined
357	0	for ( Iterator it = superProject.getRemoteArtifactRepositories().iterator(); it.hasNext(); )
358		{
359	0	ArtifactRepository superRepo = (ArtifactRepository) it.next();
360
361	0	for ( Iterator aggregatedIterator = repositories.iterator(); aggregatedIterator.hasNext(); )
362		{
363	0	ArtifactRepository repo = (ArtifactRepository) aggregatedIterator.next();
364
365		// if the repository exists in the list and was introduced by another POM's super-pom,
366		// remove it...the repository definitions from the super-POM should only be at the end of
367		// the list.
368		// if the repository has been redefined, leave it.
369	0	if ( repo.getId().equals( superRepo.getId() ) && repo.getUrl().equals( superRepo.getUrl() ) )
370		{
371	0	aggregatedIterator.remove();
372		}
373	0	}
374	0	}
375
376		// this list should contain the super-POM repositories, so we don't have to explicitly add them back.
377	0	for ( Iterator it = remoteArtifactRepositories.iterator(); it.hasNext(); )
378		{
379	0	ArtifactRepository repository = (ArtifactRepository) it.next();
380
381	0	if ( !repositories.contains( repository ) )
382		{
383	0	repositories.add( repository );
384		}
385	0	}
386
387	0	return repositories;
388		}
389
390		/**
391		* @todo desperately needs refactoring. It's just here because it's implementation is maven-project specific
392		* @return {@link Set} < {@link Artifact} >
393		*/
394		public static Set createArtifacts( ArtifactFactory artifactFactory, List dependencies, String inheritedScope,
395		ArtifactFilter dependencyFilter, MavenProject project )
396		throws InvalidDependencyVersionException
397		{
398	0	Set projectArtifacts = new LinkedHashSet( dependencies.size() );
399
400	0	for ( Iterator i = dependencies.iterator(); i.hasNext(); )
401		{
402	0	Dependency d = (Dependency) i.next();
403
404	0	String scope = d.getScope();
405
406	0	if ( StringUtils.isEmpty( scope ) )
407		{
408	0	scope = Artifact.SCOPE_COMPILE;
409
410	0	d.setScope( scope );
411		}
412
413		VersionRange versionRange;
414		try
415		{
416	0	versionRange = VersionRange.createFromVersionSpec( d.getVersion() );
417		}
418	0	catch ( InvalidVersionSpecificationException e )
419		{
420	0	throw new InvalidDependencyVersionException( "Unable to parse version '" + d.getVersion() +
421		"' for dependency '" + d.getManagementKey() + "': " + e.getMessage(), e );
422	0	}
423	0	Artifact artifact = artifactFactory.createDependencyArtifact( d.getGroupId(), d.getArtifactId(),
424		versionRange, d.getType(), d.getClassifier(),
425		scope, inheritedScope, d.isOptional() );
426
427	0	if ( Artifact.SCOPE_SYSTEM.equals( scope ) )
428		{
429	0	artifact.setFile( new File( d.getSystemPath() ) );
430		}
431
432	0	ArtifactFilter artifactFilter = dependencyFilter;
433
434		// MNG-3769: It would be nice to be able to process relocations here,
435		// so we could have this filtering step apply to post-relocated dependencies.
436		// HOWEVER, this would require a much more invasive POM resolution process
437		// in order to look for relocations, which would make the early steps in
438		// a Maven build way too heavy.
439	0	if ( artifact != null && ( artifactFilter == null \|\| artifactFilter.include( artifact ) ) )
440		{
441	0	if ( d.getExclusions() != null && !d.getExclusions().isEmpty() )
442		{
443	0	List exclusions = new ArrayList();
444	0	for ( Iterator j = d.getExclusions().iterator(); j.hasNext(); )
445		{
446	0	Exclusion e = (Exclusion) j.next();
447	0	exclusions.add( e.getGroupId() + ":" + e.getArtifactId() );
448	0	}
449
450	0	ArtifactFilter newFilter = new ExcludesArtifactFilter( exclusions );
451
452	0	if ( artifactFilter != null )
453		{
454	0	AndArtifactFilter filter = new AndArtifactFilter();
455	0	filter.add( artifactFilter );
456	0	filter.add( newFilter );
457	0	artifactFilter = filter;
458	0	}
459		else
460		{
461	0	artifactFilter = newFilter;
462		}
463		}
464
465	0	artifact.setDependencyFilter( artifactFilter );
466
467	0	if ( project != null )
468		{
469	0	artifact = project.replaceWithActiveArtifact( artifact );
470		}
471
472	0	projectArtifacts.add( artifact );
473		}
474	0	}
475
476	0	return projectArtifacts;
477		}
478
479		public List retrieveAvailableVersions( Artifact artifact, ArtifactRepository localRepository,
480		List remoteRepositories )
481		throws ArtifactMetadataRetrievalException
482		{
483	0	RepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
484		try
485		{
486	0	repositoryMetadataManager.resolve( metadata, remoteRepositories, localRepository );
487		}
488	0	catch ( RepositoryMetadataResolutionException e )
489		{
490	0	throw new ArtifactMetadataRetrievalException( e.getMessage(), e );
491	0	}
492
493		List versions;
494	0	Metadata repoMetadata = metadata.getMetadata();
495	0	if ( repoMetadata != null && repoMetadata.getVersioning() != null )
496		{
497	0	List metadataVersions = repoMetadata.getVersioning().getVersions();
498	0	versions = new ArrayList( metadataVersions.size() );
499	0	for ( Iterator i = metadataVersions.iterator(); i.hasNext(); )
500		{
501	0	String version = (String) i.next();
502	0	versions.add( new DefaultArtifactVersion( version ) );
503	0	}
504	0	}
505		else
506		{
507	0	versions = Collections.EMPTY_LIST;
508		}
509
510	0	return versions;
511		}
512		}