aboutsummaryrefslogtreecommitdiffstats
path: root/framework/src/maven/apache-maven-3.3.3/maven-compat/src/main/java/org/apache/maven/repository/legacy/resolver/DefaultLegacyArtifactCollector.java
diff options
context:
space:
mode:
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.java796
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 );
+ }
+
+}