diff options
Diffstat (limited to 'framework/src/maven/apache-maven-3.3.3/maven-compat/src/main/java/org/apache/maven/repository/legacy/resolver/DefaultLegacyArtifactCollector.java')
-rw-r--r-- | framework/src/maven/apache-maven-3.3.3/maven-compat/src/main/java/org/apache/maven/repository/legacy/resolver/DefaultLegacyArtifactCollector.java | 796 |
1 files changed, 796 insertions, 0 deletions
diff --git a/framework/src/maven/apache-maven-3.3.3/maven-compat/src/main/java/org/apache/maven/repository/legacy/resolver/DefaultLegacyArtifactCollector.java b/framework/src/maven/apache-maven-3.3.3/maven-compat/src/main/java/org/apache/maven/repository/legacy/resolver/DefaultLegacyArtifactCollector.java new file mode 100644 index 00000000..f734416b --- /dev/null +++ b/framework/src/maven/apache-maven-3.3.3/maven-compat/src/main/java/org/apache/maven/repository/legacy/resolver/DefaultLegacyArtifactCollector.java @@ -0,0 +1,796 @@ +package org.apache.maven.repository.legacy.resolver; + +/* + * 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 java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.apache.maven.artifact.Artifact; +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.resolver.ArtifactResolutionException; +import org.apache.maven.artifact.resolver.ArtifactResolutionRequest; +import org.apache.maven.artifact.resolver.ArtifactResolutionResult; +import org.apache.maven.artifact.resolver.CyclicDependencyException; +import org.apache.maven.artifact.resolver.ResolutionListener; +import org.apache.maven.artifact.resolver.ResolutionListenerForDepMgmt; +import org.apache.maven.artifact.resolver.ResolutionNode; +import org.apache.maven.artifact.resolver.filter.AndArtifactFilter; +import org.apache.maven.artifact.resolver.filter.ArtifactFilter; +import org.apache.maven.artifact.versioning.ArtifactVersion; +import org.apache.maven.artifact.versioning.ManagedVersionMap; +import org.apache.maven.artifact.versioning.OverConstrainedVersionException; +import org.apache.maven.artifact.versioning.VersionRange; +import org.apache.maven.execution.MavenSession; +import org.apache.maven.plugin.LegacySupport; +import org.apache.maven.repository.legacy.metadata.ArtifactMetadataRetrievalException; +import org.apache.maven.repository.legacy.metadata.DefaultMetadataResolutionRequest; +import org.apache.maven.repository.legacy.metadata.MetadataResolutionRequest; +import org.apache.maven.repository.legacy.resolver.conflict.ConflictResolver; +import org.codehaus.plexus.component.annotations.Component; +import org.codehaus.plexus.component.annotations.Requirement; +import org.codehaus.plexus.logging.Logger; + +/** + * @author <a href="mailto:brett@apache.org">Brett Porter</a> + * @author Jason van Zyl + */ +@Component( role = LegacyArtifactCollector.class ) +public class DefaultLegacyArtifactCollector + implements LegacyArtifactCollector +{ + @Requirement( hint = "nearest" ) + private ConflictResolver defaultConflictResolver; + + @Requirement + private Logger logger; + + @Requirement + private LegacySupport legacySupport; + + private void injectSession( ArtifactResolutionRequest request ) + { + MavenSession session = legacySupport.getSession(); + + if ( session != null ) + { + request.setOffline( session.isOffline() ); + request.setForceUpdate( session.getRequest().isUpdateSnapshots() ); + request.setServers( session.getRequest().getServers() ); + request.setMirrors( session.getRequest().getMirrors() ); + request.setProxies( session.getRequest().getProxies() ); + } + } + + public ArtifactResolutionResult collect( Set<Artifact> artifacts, Artifact originatingArtifact, + Map managedVersions, ArtifactRepository localRepository, + List<ArtifactRepository> remoteRepositories, + ArtifactMetadataSource source, ArtifactFilter filter, + List<ResolutionListener> listeners, + List<ConflictResolver> conflictResolvers ) + { + ArtifactResolutionRequest request = new ArtifactResolutionRequest(); + request.setLocalRepository( localRepository ); + request.setRemoteRepositories( remoteRepositories ); + injectSession( request ); + return collect( artifacts, originatingArtifact, managedVersions, request, source, filter, listeners, + conflictResolvers ); + } + + public ArtifactResolutionResult collect( Set<Artifact> artifacts, Artifact originatingArtifact, + Map managedVersions, ArtifactResolutionRequest repositoryRequest, + ArtifactMetadataSource source, ArtifactFilter filter, + List<ResolutionListener> listeners, + List<ConflictResolver> conflictResolvers ) + { + ArtifactResolutionResult result = new ArtifactResolutionResult(); + + result.setOriginatingArtifact( originatingArtifact ); + + if ( conflictResolvers == null ) + { + conflictResolvers = Collections.singletonList( defaultConflictResolver ); + } + + Map<Object, List<ResolutionNode>> resolvedArtifacts = new LinkedHashMap<Object, List<ResolutionNode>>(); + + ResolutionNode root = new ResolutionNode( originatingArtifact, repositoryRequest.getRemoteRepositories() ); + + try + { + root.addDependencies( artifacts, repositoryRequest.getRemoteRepositories(), filter ); + } + catch ( CyclicDependencyException e ) + { + result.addCircularDependencyException( e ); + + return result; + } + catch ( OverConstrainedVersionException e ) + { + result.addVersionRangeViolation( e ); + + return result; + } + + ManagedVersionMap versionMap = getManagedVersionsMap( originatingArtifact, managedVersions ); + + try + { + recurse( result, root, resolvedArtifacts, versionMap, repositoryRequest, source, filter, listeners, + conflictResolvers ); + } + catch ( CyclicDependencyException e ) + { + logger.debug( "While recursing: " + e.getMessage(), e ); + result.addCircularDependencyException( e ); + } + catch ( OverConstrainedVersionException e ) + { + logger.debug( "While recursing: " + e.getMessage(), e ); + result.addVersionRangeViolation( e ); + } + catch ( ArtifactResolutionException e ) + { + logger.debug( "While recursing: " + e.getMessage(), e ); + result.addErrorArtifactException( e ); + } + + Set<ResolutionNode> set = new LinkedHashSet<ResolutionNode>(); + + for ( List<ResolutionNode> nodes : resolvedArtifacts.values() ) + { + for ( ResolutionNode node : nodes ) + { + if ( !node.equals( root ) && node.isActive() ) + { + Artifact artifact = node.getArtifact(); + + try + { + if ( node.filterTrail( filter ) ) + { + // If it was optional and not a direct dependency, + // we don't add it or its children, just allow the update of the version and artifactScope + if ( node.isChildOfRootNode() || !artifact.isOptional() ) + { + artifact.setDependencyTrail( node.getDependencyTrail() ); + + set.add( node ); + + // This is required right now. + result.addArtifact( artifact ); + } + } + } + catch ( OverConstrainedVersionException e ) + { + result.addVersionRangeViolation( e ); + } + } + } + } + + result.setArtifactResolutionNodes( set ); + + return result; + } + + /** + * Get the map of managed versions, removing the originating artifact if it is also in managed versions + * + * @param originatingArtifact artifact we are processing + * @param managedVersions original managed versions + */ + private ManagedVersionMap getManagedVersionsMap( Artifact originatingArtifact, Map managedVersions ) + { + ManagedVersionMap versionMap; + if ( ( managedVersions != null ) && ( managedVersions instanceof ManagedVersionMap ) ) + { + versionMap = (ManagedVersionMap) managedVersions; + } + else + { + versionMap = new ManagedVersionMap( managedVersions ); + } + + /* remove the originating artifact if it is also in managed versions to avoid being modified during resolution */ + Artifact managedOriginatingArtifact = versionMap.get( originatingArtifact.getDependencyConflictId() ); + + if ( managedOriginatingArtifact != null ) + { + // TODO we probably want to warn the user that he is building an artifact with + // different values than in dependencyManagement + if ( managedVersions instanceof ManagedVersionMap ) + { + /* avoid modifying the managedVersions parameter creating a new map */ + versionMap = new ManagedVersionMap( managedVersions ); + } + versionMap.remove( originatingArtifact.getDependencyConflictId() ); + } + + return versionMap; + } + + private void recurse( ArtifactResolutionResult result, ResolutionNode node, + Map<Object, List<ResolutionNode>> resolvedArtifacts, ManagedVersionMap managedVersions, + ArtifactResolutionRequest request, ArtifactMetadataSource source, ArtifactFilter filter, + List<ResolutionListener> listeners, List<ConflictResolver> conflictResolvers ) + throws ArtifactResolutionException + { + fireEvent( ResolutionListener.TEST_ARTIFACT, listeners, node ); + + Object key = node.getKey(); + + // TODO: Does this check need to happen here? Had to add the same call + // below when we iterate on child nodes -- will that suffice? + if ( managedVersions.containsKey( key ) ) + { + manageArtifact( node, managedVersions, listeners ); + } + + List<ResolutionNode> previousNodes = resolvedArtifacts.get( key ); + + if ( previousNodes != null ) + { + for ( ResolutionNode previous : previousNodes ) + { + try + { + if ( previous.isActive() ) + { + // Version mediation + VersionRange previousRange = previous.getArtifact().getVersionRange(); + VersionRange currentRange = node.getArtifact().getVersionRange(); + + if ( ( previousRange != null ) && ( currentRange != null ) ) + { + // TODO: shouldn't need to double up on this work, only done for simplicity of handling + // recommended + // version but the restriction is identical + VersionRange newRange = previousRange.restrict( currentRange ); + // TODO: ick. this forces the OCE that should have come from the previous call. It is still + // correct + if ( newRange.isSelectedVersionKnown( previous.getArtifact() ) ) + { + fireEvent( ResolutionListener.RESTRICT_RANGE, listeners, node, previous.getArtifact(), + newRange ); + } + previous.getArtifact().setVersionRange( newRange ); + node.getArtifact().setVersionRange( currentRange.restrict( previousRange ) ); + + // Select an appropriate available version from the (now restricted) range + // Note this version was selected before to get the appropriate POM + // But it was reset by the call to setVersionRange on restricting the version + ResolutionNode[] resetNodes = { previous, node }; + for ( int j = 0; j < 2; j++ ) + { + Artifact resetArtifact = resetNodes[j].getArtifact(); + + // MNG-2123: if the previous node was not a range, then it wouldn't have any available + // versions. We just clobbered the selected version above. (why? i have no idea.) + // So since we are here and this is ranges we must go figure out the version (for a + // third time...) + if ( resetArtifact.getVersion() == null && resetArtifact.getVersionRange() != null ) + { + + // go find the version. This is a total hack. See previous comment. + List<ArtifactVersion> versions = resetArtifact.getAvailableVersions(); + if ( versions == null ) + { + try + { + MetadataResolutionRequest metadataRequest = + new DefaultMetadataResolutionRequest( request ); + metadataRequest.setArtifact( resetArtifact ); + versions = source.retrieveAvailableVersions( metadataRequest ); + resetArtifact.setAvailableVersions( versions ); + } + catch ( ArtifactMetadataRetrievalException e ) + { + resetArtifact.setDependencyTrail( node.getDependencyTrail() ); + throw new ArtifactResolutionException( + "Unable to get dependency information: " + + e.getMessage(), resetArtifact, + request.getRemoteRepositories(), e ); + } + } + // end hack + + // MNG-2861: match version can return null + ArtifactVersion selectedVersion = + resetArtifact.getVersionRange().matchVersion( resetArtifact.getAvailableVersions() ); + if ( selectedVersion != null ) + { + resetArtifact.selectVersion( selectedVersion.toString() ); + } + else + { + throw new OverConstrainedVersionException( " Unable to find a version in " + + resetArtifact.getAvailableVersions() + " to match the range " + + resetArtifact.getVersionRange(), resetArtifact ); + } + + fireEvent( ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, resetNodes[j] ); + } + } + } + + // Conflict Resolution + ResolutionNode resolved = null; + for ( Iterator j = conflictResolvers.iterator(); ( resolved == null ) && j.hasNext(); ) + { + ConflictResolver conflictResolver = (ConflictResolver) j.next(); + + resolved = conflictResolver.resolveConflict( previous, node ); + } + + if ( resolved == null ) + { + // TODO: add better exception that can detail the two conflicting artifacts + ArtifactResolutionException are = + new ArtifactResolutionException( "Cannot resolve artifact version conflict between " + + previous.getArtifact().getVersion() + " and " + node.getArtifact().getVersion(), + previous.getArtifact() ); + result.addVersionRangeViolation( are ); + } + + if ( ( resolved != previous ) && ( resolved != node ) ) + { + // TODO: add better exception + result.addVersionRangeViolation( new ArtifactResolutionException( + "Conflict resolver returned unknown resolution node: ", + resolved.getArtifact() ) ); + } + + // TODO: should this be part of mediation? + // previous one is more dominant + ResolutionNode nearest; + ResolutionNode farthest; + + if ( resolved == previous ) + { + nearest = previous; + farthest = node; + } + else + { + nearest = node; + farthest = previous; + } + + if ( checkScopeUpdate( farthest, nearest, listeners ) ) + { + // if we need to update artifactScope of nearest to use farthest artifactScope, use the + // nearest version, but farthest artifactScope + nearest.disable(); + farthest.getArtifact().setVersion( nearest.getArtifact().getVersion() ); + fireEvent( ResolutionListener.OMIT_FOR_NEARER, listeners, nearest, farthest.getArtifact() ); + } + else + { + farthest.disable(); + fireEvent( ResolutionListener.OMIT_FOR_NEARER, listeners, farthest, nearest.getArtifact() ); + } + } + } + catch ( OverConstrainedVersionException e ) + { + result.addVersionRangeViolation( e ); + } + } + } + else + { + previousNodes = new ArrayList<ResolutionNode>(); + + resolvedArtifacts.put( key, previousNodes ); + } + previousNodes.add( node ); + + if ( node.isActive() ) + { + fireEvent( ResolutionListener.INCLUDE_ARTIFACT, listeners, node ); + } + + // don't pull in the transitive deps of a system-scoped dependency. + if ( node.isActive() && !Artifact.SCOPE_SYSTEM.equals( node.getArtifact().getScope() ) ) + { + fireEvent( ResolutionListener.PROCESS_CHILDREN, listeners, node ); + + Artifact parentArtifact = node.getArtifact(); + + for ( Iterator i = node.getChildrenIterator(); i.hasNext(); ) + { + ResolutionNode child = (ResolutionNode) i.next(); + + try + { + + // We leave in optional ones, but don't pick up its dependencies + if ( !child.isResolved() && ( !child.getArtifact().isOptional() || child.isChildOfRootNode() ) ) + { + Artifact artifact = child.getArtifact(); + artifact.setDependencyTrail( node.getDependencyTrail() ); + List<ArtifactRepository> childRemoteRepositories = child.getRemoteRepositories(); + + MetadataResolutionRequest metadataRequest = + new DefaultMetadataResolutionRequest( request ); + metadataRequest.setArtifact( artifact ); + metadataRequest.setRemoteRepositories( childRemoteRepositories ); + + try + { + ResolutionGroup rGroup; + + Object childKey; + do + { + childKey = child.getKey(); + + if ( managedVersions.containsKey( childKey ) ) + { + // If this child node is a managed dependency, ensure + // we are using the dependency management version + // of this child if applicable b/c we want to use the + // managed version's POM, *not* any other version's POM. + // We retrieve the POM below in the retrieval step. + manageArtifact( child, managedVersions, listeners ); + + // Also, we need to ensure that any exclusions it presents are + // added to the artifact before we retrive the metadata + // for the artifact; otherwise we may end up with unwanted + // dependencies. + Artifact ma = managedVersions.get( childKey ); + ArtifactFilter managedExclusionFilter = ma.getDependencyFilter(); + if ( null != managedExclusionFilter ) + { + if ( null != artifact.getDependencyFilter() ) + { + AndArtifactFilter aaf = new AndArtifactFilter(); + aaf.add( artifact.getDependencyFilter() ); + aaf.add( managedExclusionFilter ); + artifact.setDependencyFilter( aaf ); + } + else + { + artifact.setDependencyFilter( managedExclusionFilter ); + } + } + } + + if ( artifact.getVersion() == null ) + { + // set the recommended version + // TODO: maybe its better to just pass the range through to retrieval and use a + // transformation? + ArtifactVersion version; + if ( !artifact.isSelectedVersionKnown() ) + { + List<ArtifactVersion> versions = artifact.getAvailableVersions(); + if ( versions == null ) + { + versions = source.retrieveAvailableVersions( metadataRequest ); + artifact.setAvailableVersions( versions ); + } + + Collections.sort( versions ); + + VersionRange versionRange = artifact.getVersionRange(); + + version = versionRange.matchVersion( versions ); + + if ( version == null ) + { + if ( versions.isEmpty() ) + { + throw new OverConstrainedVersionException( + "No versions are present in the repository for the artifact with a range " + + versionRange, + artifact, + childRemoteRepositories ); + } + + throw new OverConstrainedVersionException( "Couldn't find a version in " + + versions + " to match range " + versionRange, artifact, + childRemoteRepositories ); + } + } + else + { + version = artifact.getSelectedVersion(); + } + + artifact.selectVersion( version.toString() ); + fireEvent( ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, child ); + } + + rGroup = source.retrieve( metadataRequest ); + + if ( rGroup == null ) + { + break; + } + } + while( !childKey.equals( child.getKey() ) ); + + if ( parentArtifact != null && parentArtifact.getDependencyFilter() != null + && !parentArtifact.getDependencyFilter().include( artifact ) ) + { + // MNG-3769: the [probably relocated] artifact is excluded. + // We could process exclusions on relocated artifact details in the + // MavenMetadataSource.createArtifacts(..) step, BUT that would + // require resolving the POM from the repository very early on in + // the build. + continue; + } + + // TODO might be better to have source.retrieve() throw a specific exception for this + // situation + // and catch here rather than have it return null + if ( rGroup == null ) + { + // relocated dependency artifact is declared excluded, no need to add and recurse + // further + continue; + } + + child.addDependencies( rGroup.getArtifacts(), rGroup.getResolutionRepositories(), filter ); + + } + catch ( CyclicDependencyException e ) + { + // would like to throw this, but we have crappy stuff in the repo + + fireEvent( ResolutionListener.OMIT_FOR_CYCLE, listeners, + new ResolutionNode( e.getArtifact(), childRemoteRepositories, child ) ); + } + catch ( ArtifactMetadataRetrievalException e ) + { + artifact.setDependencyTrail( node.getDependencyTrail() ); + + throw new ArtifactResolutionException( "Unable to get dependency information for " + + artifact.getId() + ": " + e.getMessage(), artifact, childRemoteRepositories, e ); + } + + ArtifactResolutionRequest subRequest = new ArtifactResolutionRequest( metadataRequest ); + subRequest.setServers( request.getServers() ); + subRequest.setMirrors( request.getMirrors() ); + subRequest.setProxies( request.getProxies() ); + recurse( result, child, resolvedArtifacts, managedVersions, subRequest, source, filter, + listeners, conflictResolvers ); + } + } + catch ( OverConstrainedVersionException e ) + { + result.addVersionRangeViolation( e ); + } + catch ( ArtifactResolutionException e ) + { + result.addMetadataResolutionException( e ); + } + } + + fireEvent( ResolutionListener.FINISH_PROCESSING_CHILDREN, listeners, node ); + } + } + + private void manageArtifact( ResolutionNode node, ManagedVersionMap managedVersions, + List<ResolutionListener> listeners ) + { + Artifact artifact = managedVersions.get( node.getKey() ); + + // Before we update the version of the artifact, we need to know + // whether we are working on a transitive dependency or not. This + // allows depMgmt to always override transitive dependencies, while + // explicit child override depMgmt (viz. depMgmt should only + // provide defaults to children, but should override transitives). + // We can do this by calling isChildOfRootNode on the current node. + + if ( ( artifact.getVersion() != null ) + && ( !node.isChildOfRootNode() || node.getArtifact().getVersion() == null ) ) + { + fireEvent( ResolutionListener.MANAGE_ARTIFACT_VERSION, listeners, node, artifact ); + node.getArtifact().setVersion( artifact.getVersion() ); + } + + if ( ( artifact.getScope() != null ) && ( !node.isChildOfRootNode() || node.getArtifact().getScope() == null ) ) + { + fireEvent( ResolutionListener.MANAGE_ARTIFACT_SCOPE, listeners, node, artifact ); + node.getArtifact().setScope( artifact.getScope() ); + } + + if ( Artifact.SCOPE_SYSTEM.equals( node.getArtifact().getScope() ) && ( node.getArtifact().getFile() == null ) + && ( artifact.getFile() != null ) ) + { + fireEvent( ResolutionListener.MANAGE_ARTIFACT_SYSTEM_PATH, listeners, node, artifact ); + node.getArtifact().setFile( artifact.getFile() ); + } + } + + /** + * Check if the artifactScope needs to be updated. <a + * href="http://docs.codehaus.org/x/IGU#DependencyMediationandConflictResolution-Scoperesolution">More info</a>. + * + * @param farthest farthest resolution node + * @param nearest nearest resolution node + * @param listeners + */ + boolean checkScopeUpdate( ResolutionNode farthest, ResolutionNode nearest, List<ResolutionListener> listeners ) + { + boolean updateScope = false; + Artifact farthestArtifact = farthest.getArtifact(); + Artifact nearestArtifact = nearest.getArtifact(); + + /* farthest is runtime and nearest has lower priority, change to runtime */ + if ( Artifact.SCOPE_RUNTIME.equals( farthestArtifact.getScope() ) + && ( Artifact.SCOPE_TEST.equals( nearestArtifact.getScope() ) + || Artifact.SCOPE_PROVIDED.equals( nearestArtifact.getScope() ) ) ) + { + updateScope = true; + } + + /* farthest is compile and nearest is not (has lower priority), change to compile */ + if ( Artifact.SCOPE_COMPILE.equals( farthestArtifact.getScope() ) + && !Artifact.SCOPE_COMPILE.equals( nearestArtifact.getScope() ) ) + { + updateScope = true; + } + + /* current POM rules all, if nearest is in current pom, do not update its artifactScope */ + if ( ( nearest.getDepth() < 2 ) && updateScope ) + { + updateScope = false; + + fireEvent( ResolutionListener.UPDATE_SCOPE_CURRENT_POM, listeners, nearest, farthestArtifact ); + } + + if ( updateScope ) + { + fireEvent( ResolutionListener.UPDATE_SCOPE, listeners, nearest, farthestArtifact ); + + // previously we cloned the artifact, but it is more effecient to just update the artifactScope + // if problems are later discovered that the original object needs its original artifactScope value, cloning + // may + // again be appropriate + nearestArtifact.setScope( farthestArtifact.getScope() ); + } + + return updateScope; + } + + private void fireEvent( int event, List<ResolutionListener> listeners, ResolutionNode node ) + { + fireEvent( event, listeners, node, null ); + } + + private void fireEvent( int event, List<ResolutionListener> listeners, ResolutionNode node, Artifact replacement ) + { + fireEvent( event, listeners, node, replacement, null ); + } + + private void fireEvent( int event, List<ResolutionListener> listeners, ResolutionNode node, Artifact replacement, + VersionRange newRange ) + { + for ( ResolutionListener listener : listeners ) + { + switch ( event ) + { + case ResolutionListener.TEST_ARTIFACT: + listener.testArtifact( node.getArtifact() ); + break; + case ResolutionListener.PROCESS_CHILDREN: + listener.startProcessChildren( node.getArtifact() ); + break; + case ResolutionListener.FINISH_PROCESSING_CHILDREN: + listener.endProcessChildren( node.getArtifact() ); + break; + case ResolutionListener.INCLUDE_ARTIFACT: + listener.includeArtifact( node.getArtifact() ); + break; + case ResolutionListener.OMIT_FOR_NEARER: + listener.omitForNearer( node.getArtifact(), replacement ); + break; + case ResolutionListener.OMIT_FOR_CYCLE: + listener.omitForCycle( node.getArtifact() ); + break; + case ResolutionListener.UPDATE_SCOPE: + listener.updateScope( node.getArtifact(), replacement.getScope() ); + break; + case ResolutionListener.UPDATE_SCOPE_CURRENT_POM: + listener.updateScopeCurrentPom( node.getArtifact(), replacement.getScope() ); + break; + case ResolutionListener.MANAGE_ARTIFACT_VERSION: + if ( listener instanceof ResolutionListenerForDepMgmt ) + { + ResolutionListenerForDepMgmt asImpl = (ResolutionListenerForDepMgmt) listener; + asImpl.manageArtifactVersion( node.getArtifact(), replacement ); + } + else + { + listener.manageArtifact( node.getArtifact(), replacement ); + } + break; + case ResolutionListener.MANAGE_ARTIFACT_SCOPE: + if ( listener instanceof ResolutionListenerForDepMgmt ) + { + ResolutionListenerForDepMgmt asImpl = (ResolutionListenerForDepMgmt) listener; + asImpl.manageArtifactScope( node.getArtifact(), replacement ); + } + else + { + listener.manageArtifact( node.getArtifact(), replacement ); + } + break; + case ResolutionListener.MANAGE_ARTIFACT_SYSTEM_PATH: + if ( listener instanceof ResolutionListenerForDepMgmt ) + { + ResolutionListenerForDepMgmt asImpl = (ResolutionListenerForDepMgmt) listener; + asImpl.manageArtifactSystemPath( node.getArtifact(), replacement ); + } + else + { + listener.manageArtifact( node.getArtifact(), replacement ); + } + break; + case ResolutionListener.SELECT_VERSION_FROM_RANGE: + listener.selectVersionFromRange( node.getArtifact() ); + break; + case ResolutionListener.RESTRICT_RANGE: + if ( node.getArtifact().getVersionRange().hasRestrictions() + || replacement.getVersionRange().hasRestrictions() ) + { + listener.restrictRange( node.getArtifact(), replacement, newRange ); + } + break; + default: + throw new IllegalStateException( "Unknown event: " + event ); + } + } + } + + public ArtifactResolutionResult collect( Set<Artifact> artifacts, Artifact originatingArtifact, + Map managedVersions, ArtifactRepository localRepository, + List<ArtifactRepository> remoteRepositories, + ArtifactMetadataSource source, ArtifactFilter filter, + List<ResolutionListener> listeners ) + { + return collect( artifacts, originatingArtifact, managedVersions, localRepository, remoteRepositories, source, + filter, listeners, null ); + } + + public ArtifactResolutionResult collect( Set<Artifact> artifacts, Artifact originatingArtifact, + ArtifactRepository localRepository, + List<ArtifactRepository> remoteRepositories, + ArtifactMetadataSource source, ArtifactFilter filter, + List<ResolutionListener> listeners ) + { + return collect( artifacts, originatingArtifact, null, localRepository, remoteRepositories, source, filter, + listeners ); + } + +} |