}
}
//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
// TODO: use as conflict resolver(s), chain
// TODO: should this be part of mediation?
// previous one is more dominant
ResolutionNode nearest;
ResolutionNode farthest;
if ( previous.getDepth() <= node.getDepth() )
{
nearest = previous;
farthest = node;
}
else
{
nearest = node;
farthest = previous;
}
if ( checkScopeUpdate( farthest, nearest, listeners ) )
{
// if we need to update scope of nearest to use farthest scope, use the nearest version, but farthest scope
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() );
}
}
}
}
else
{
previousNodes = new ArrayList();
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();
// We leave in optional ones, but don't pick up its dependencies
if ( !child.isResolved() && ( !child.getArtifact().isOptional() || child.isChildOfRootNode() ) )
{
Artifact artifact = child.getArtifact();
List childRemoteRepositories = child.getRemoteRepositories();
try
{
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 retrieve the metadata
// for the artifact; otherwise we may end up with unwanted
// dependencies.
Artifact ma = (Artifact) 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() )
{
version = artifact.getSelectedVersion();
}
else
{
//go find the version
List versions = artifact.getAvailableVersions();
if ( versions == null )
{
versions = source.retrieveAvailableVersions( artifact, localRepository,
childRemoteRepositories );
artifact.setAvailableVersions( versions );
}
Collections.sort( versions );
VersionRange versionRange = artifact.getVersionRange();
version = versionRange.matchVersion( versions );
if ( version == null )
{
// Getting the dependency trail so it can be logged in the exception
artifact.setDependencyTrail( node.getDependencyTrail() );
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 );
}
}
//this is dangerous because artifact.getSelectedVersion() can
//return null. However it is ok here because we first check if the
//selected version is known. As currently coded we can't get a null here.
artifact.selectVersion( version.toString() );
fireEvent( ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, child );
}
Artifact relocated = source.retrieveRelocatedArtifact( artifact, localRepository, childRemoteRepositories );
if ( relocated != null && !artifact.equals( relocated ) )