Coverage Report - org.apache.maven.artifact.resolver.DefaultArtifactCollector
 
Classes in this File Line Coverage Branch Coverage Complexity
DefaultArtifactCollector
0%
0/208
0%
0/144
8.444
 
 1  
 package org.apache.maven.artifact.resolver;
 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.metadata.ArtifactMetadataRetrievalException;
 24  
 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
 25  
 import org.apache.maven.artifact.metadata.ResolutionGroup;
 26  
 import org.apache.maven.artifact.repository.ArtifactRepository;
 27  
 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
 28  
 import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
 29  
 import org.apache.maven.artifact.versioning.ArtifactVersion;
 30  
 import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
 31  
 import org.apache.maven.artifact.versioning.VersionRange;
 32  
 import org.apache.maven.artifact.versioning.ManagedVersionMap;
 33  
 
 34  
 import java.util.ArrayList;
 35  
 import java.util.Collections;
 36  
 import java.util.Iterator;
 37  
 import java.util.LinkedHashMap;
 38  
 import java.util.LinkedHashSet;
 39  
 import java.util.List;
 40  
 import java.util.Map;
 41  
 import java.util.Set;
 42  
 
 43  
 /**
 44  
  * Default implementation of the artifact collector.
 45  
  *
 46  
  * @author <a href="mailto:brett@apache.org">Brett Porter</a>
 47  
  * @version $Id: DefaultArtifactCollector.java 736543 2009-01-22 03:33:16Z jdcasey $
 48  
  */
 49  0
 public class DefaultArtifactCollector
 50  
     implements ArtifactCollector
 51  
 {
 52  
     public ArtifactResolutionResult collect( Set artifacts, Artifact originatingArtifact,
 53  
                                              ArtifactRepository localRepository, List remoteRepositories,
 54  
                                              ArtifactMetadataSource source, ArtifactFilter filter, List listeners )
 55  
         throws ArtifactResolutionException
 56  
     {
 57  0
         return collect( artifacts, originatingArtifact, Collections.EMPTY_MAP, localRepository, remoteRepositories,
 58  
                         source, filter, listeners );
 59  
     }
 60  
 
 61  
     public ArtifactResolutionResult collect( Set artifacts, Artifact originatingArtifact, Map managedVersions,
 62  
                                              ArtifactRepository localRepository, List remoteRepositories,
 63  
                                              ArtifactMetadataSource source, ArtifactFilter filter, List listeners )
 64  
         throws ArtifactResolutionException
 65  
     {
 66  0
         Map resolvedArtifacts = new LinkedHashMap();
 67  
 
 68  0
         ResolutionNode root = new ResolutionNode( originatingArtifact, remoteRepositories );
 69  
 
 70  0
         root.addDependencies( artifacts, remoteRepositories, filter );
 71  
 
 72  0
         ManagedVersionMap versionMap = getManagedVersionsMap( originatingArtifact, managedVersions );
 73  
 
 74  0
         recurse( originatingArtifact, root, resolvedArtifacts, versionMap, localRepository, remoteRepositories, source, filter,
 75  
                  listeners );
 76  
 
 77  0
         Set set = new LinkedHashSet();
 78  
 
 79  0
         for ( Iterator i = resolvedArtifacts.values().iterator(); i.hasNext(); )
 80  
         {
 81  0
             List nodes = (List) i.next();
 82  0
             for ( Iterator j = nodes.iterator(); j.hasNext(); )
 83  
             {
 84  0
                 ResolutionNode node = (ResolutionNode) j.next();
 85  0
                 if ( !node.equals( root ) && node.isActive() )
 86  
                 {
 87  0
                     Artifact artifact = node.getArtifact();
 88  
 
 89  0
                     if ( node.filterTrail( filter ) )
 90  
                     {
 91  
                         // If it was optional and not a direct dependency,
 92  
                         // we don't add it or its children, just allow the update of the version and scope
 93  0
                         if ( node.isChildOfRootNode() || !artifact.isOptional() )
 94  
                         {
 95  0
                             artifact.setDependencyTrail( node.getDependencyTrail() );
 96  
 
 97  0
                             set.add( node );
 98  
                         }
 99  
                     }
 100  
                 }
 101  0
             }
 102  0
         }
 103  
 
 104  0
         ArtifactResolutionResult result = new ArtifactResolutionResult();
 105  0
         result.setArtifactResolutionNodes( set );
 106  0
         return result;
 107  
     }
 108  
 
 109  
     /**
 110  
      * Get the map of managed versions, removing the originating artifact if it is also in managed versions
 111  
      * @param originatingArtifact artifact we are processing
 112  
      * @param managedVersions original managed versions
 113  
      */
 114  
     private ManagedVersionMap getManagedVersionsMap( Artifact originatingArtifact, Map managedVersions )
 115  
     {
 116  
         ManagedVersionMap versionMap;
 117  0
         if ( managedVersions != null && managedVersions instanceof ManagedVersionMap )
 118  
         {
 119  0
             versionMap = (ManagedVersionMap) managedVersions;
 120  
         }
 121  
         else
 122  
         {
 123  0
             versionMap = new ManagedVersionMap( managedVersions );
 124  
         }
 125  
 
 126  
         /* remove the originating artifact if it is also in managed versions to avoid being modified during resolution */
 127  0
         Artifact managedOriginatingArtifact = (Artifact) versionMap.get( originatingArtifact.getDependencyConflictId() );
 128  0
         if ( managedOriginatingArtifact != null )
 129  
         {
 130  
             // TODO we probably want to warn the user that he is building an artifact with
 131  
             // different values than in dependencyManagement
 132  0
             if ( managedVersions instanceof ManagedVersionMap )
 133  
             {
 134  
                 /* avoid modifying the managedVersions parameter creating a new map */
 135  0
                 versionMap = new ManagedVersionMap( managedVersions );
 136  
             }
 137  0
             versionMap.remove( originatingArtifact.getDependencyConflictId() );
 138  
         }
 139  
 
 140  0
         return versionMap;
 141  
     }
 142  
 
 143  
     private void recurse( Artifact originatingArtifact, ResolutionNode node, Map resolvedArtifacts, ManagedVersionMap managedVersions,
 144  
                           ArtifactRepository localRepository, List remoteRepositories, ArtifactMetadataSource source,
 145  
                           ArtifactFilter filter, List listeners )
 146  
         throws CyclicDependencyException, ArtifactResolutionException, OverConstrainedVersionException
 147  
     {
 148  0
         fireEvent( ResolutionListener.TEST_ARTIFACT, listeners, node );
 149  
 
 150  0
         Object key = node.getKey();
 151  
 
 152  
         // TODO: Does this check need to happen here?  Had to add the same call
 153  
         // below when we iterate on child nodes -- will that suffice?
 154  0
         if ( managedVersions.containsKey( key ))
 155  
         {
 156  0
             manageArtifact( node, managedVersions, listeners );
 157  
         }
 158  
 
 159  0
         List previousNodes = (List) resolvedArtifacts.get( key );
 160  0
         if ( previousNodes != null )
 161  
         {
 162  0
             for ( Iterator i = previousNodes.iterator(); i.hasNext(); )
 163  
             {
 164  0
                 ResolutionNode previous = (ResolutionNode) i.next();
 165  
 
 166  0
                 if ( previous.isActive() )
 167  
                 {
 168  
                     // Version mediation
 169  0
                     VersionRange previousRange = previous.getArtifact().getVersionRange();
 170  0
                     VersionRange currentRange = node.getArtifact().getVersionRange();
 171  
 
 172  0
                     if ( previousRange != null && currentRange != null )
 173  
                     {
 174  
                         // TODO: shouldn't need to double up on this work, only done for simplicity of handling recommended
 175  
                         // version but the restriction is identical
 176  0
                         VersionRange newRange = previousRange.restrict( currentRange );
 177  
                         // TODO: ick. this forces the OCE that should have come from the previous call. It is still correct
 178  0
                         if ( newRange.isSelectedVersionKnown( previous.getArtifact() ) )
 179  
                         {
 180  0
                             fireEvent( ResolutionListener.RESTRICT_RANGE, listeners, node, previous.getArtifact(),
 181  
                                        newRange );
 182  
                         }
 183  0
                         previous.getArtifact().setVersionRange( newRange );
 184  0
                         node.getArtifact().setVersionRange( currentRange.restrict( previousRange ) );
 185  
 
 186  
                         //Select an appropriate available version from the (now restricted) range
 187  
                         //Note this version was selected before to get the appropriate POM
 188  
                         //But it was reset by the call to setVersionRange on restricting the version
 189  0
                         ResolutionNode[] resetNodes = {previous, node};
 190  0
                         for ( int j = 0; j < 2; j++ )
 191  
                         {
 192  0
                             Artifact resetArtifact = resetNodes[j].getArtifact();
 193  
 
 194  
                             //MNG-2123: if the previous node was not a range, then it wouldn't have any available
 195  
                             //versions. We just clobbered the selected version above. (why? i have no idea.)
 196  
                             //So since we are here and this is ranges we must go figure out the version (for a third time...)
 197  0
                             if ( resetArtifact.getVersion() == null && resetArtifact.getVersionRange() != null )
 198  
                             {
 199  
 
 200  
                                 // go find the version. This is a total hack. See previous comment.
 201  0
                                 List versions = resetArtifact.getAvailableVersions();
 202  0
                                 if ( versions == null )
 203  
                                 {
 204  
                                     try
 205  
                                     {
 206  0
                                         versions =
 207  
                                             source.retrieveAvailableVersions( resetArtifact, localRepository,
 208  
                                                                               remoteRepositories );
 209  0
                                         resetArtifact.setAvailableVersions( versions );
 210  
                                     }
 211  0
                                     catch ( ArtifactMetadataRetrievalException e )
 212  
                                     {
 213  0
                                         resetArtifact.setDependencyTrail( node.getDependencyTrail() );
 214  0
                                         throw new ArtifactResolutionException(
 215  
                                                                                "Unable to get dependency information: " +
 216  
                                                                                    e.getMessage(), resetArtifact,
 217  
                                                                                remoteRepositories, e );
 218  0
                                     }
 219  
                                 }
 220  
                                 //end hack
 221  
 
 222  
                                 //MNG-2861: match version can return null
 223  0
                                 ArtifactVersion selectedVersion = resetArtifact.getVersionRange().matchVersion( resetArtifact.getAvailableVersions() );
 224  0
                                 if (selectedVersion != null)
 225  
                                 {
 226  0
                                   resetArtifact.selectVersion( selectedVersion.toString() );
 227  
                                 }
 228  
                                 else
 229  
                                 {
 230  0
                                   throw new OverConstrainedVersionException(" Unable to find a version in "+ resetArtifact.getAvailableVersions()+" to match the range "+ resetArtifact.getVersionRange(), resetArtifact);
 231  
                                 }
 232  
 
 233  0
                                 fireEvent( ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, resetNodes[j] );
 234  
                             }
 235  
                         }
 236  
                     }
 237  
 
 238  
                     // Conflict Resolution
 239  
                     // TODO: use as conflict resolver(s), chain
 240  
 
 241  
                     // TODO: should this be part of mediation?
 242  
                     // previous one is more dominant
 243  
                     ResolutionNode nearest;
 244  
                     ResolutionNode farthest;
 245  0
                     if ( previous.getDepth() <= node.getDepth() )
 246  
                     {
 247  0
                         nearest = previous;
 248  0
                         farthest = node;
 249  
                     }
 250  
                     else
 251  
                     {
 252  0
                         nearest = node;
 253  0
                         farthest = previous;
 254  
                     }
 255  
 
 256  0
                     if ( checkScopeUpdate( farthest, nearest, listeners ) )
 257  
                     {
 258  
                         // if we need to update scope of nearest to use farthest scope, use the nearest version, but farthest scope
 259  0
                         nearest.disable();
 260  0
                         farthest.getArtifact().setVersion( nearest.getArtifact().getVersion() );
 261  0
                         fireEvent( ResolutionListener.OMIT_FOR_NEARER, listeners, nearest, farthest.getArtifact() );
 262  
                     }
 263  
                     else
 264  
                     {
 265  0
                         farthest.disable();
 266  0
                         fireEvent( ResolutionListener.OMIT_FOR_NEARER, listeners, farthest, nearest.getArtifact() );
 267  
                     }
 268  
                 }
 269  0
             }
 270  
         }
 271  
         else
 272  
         {
 273  0
             previousNodes = new ArrayList();
 274  0
             resolvedArtifacts.put( key, previousNodes );
 275  
         }
 276  0
         previousNodes.add( node );
 277  
 
 278  0
         if ( node.isActive() )
 279  
         {
 280  0
             fireEvent( ResolutionListener.INCLUDE_ARTIFACT, listeners, node );
 281  
         }
 282  
 
 283  
         // don't pull in the transitive deps of a system-scoped dependency.
 284  0
         if ( node.isActive() && !Artifact.SCOPE_SYSTEM.equals( node.getArtifact().getScope() ) )
 285  
         {
 286  0
             fireEvent( ResolutionListener.PROCESS_CHILDREN, listeners, node );
 287  
 
 288  0
             Artifact parentArtifact = node.getArtifact();
 289  
             
 290  0
             for ( Iterator i = node.getChildrenIterator(); i.hasNext(); )
 291  
             {
 292  0
                 ResolutionNode child = (ResolutionNode) i.next();
 293  
                 // We leave in optional ones, but don't pick up its dependencies
 294  0
                 if ( !child.isResolved() && ( !child.getArtifact().isOptional() || child.isChildOfRootNode() ) )
 295  
                 {
 296  0
                     List childRemoteRepositories = child.getRemoteRepositories();
 297  0
                     Artifact artifact = child.getArtifact();
 298  
                     
 299  
                     try
 300  
                     {
 301  
                         Object childKey;
 302  
                         do
 303  
                         {
 304  0
                             childKey = child.getKey();
 305  
 
 306  0
                             if ( managedVersions.containsKey( childKey ) )
 307  
                             {
 308  
                                 // If this child node is a managed dependency, ensure
 309  
                                 // we are using the dependency management version
 310  
                                 // of this child if applicable b/c we want to use the
 311  
                                 // managed version's POM, *not* any other version's POM.
 312  
                                 // We retrieve the POM below in the retrieval step.
 313  0
                                 manageArtifact( child, managedVersions, listeners );
 314  
 
 315  
                                 // Also, we need to ensure that any exclusions it presents are
 316  
                                 // added to the artifact before we retrieve the metadata
 317  
                                 // for the artifact; otherwise we may end up with unwanted
 318  
                                 // dependencies.
 319  0
                                 Artifact ma = (Artifact) managedVersions.get( childKey );
 320  0
                                 ArtifactFilter managedExclusionFilter = ma.getDependencyFilter();
 321  0
                                 if ( null != managedExclusionFilter )
 322  
                                 {
 323  0
                                     if ( null != artifact.getDependencyFilter() )
 324  
                                     {
 325  0
                                         AndArtifactFilter aaf = new AndArtifactFilter();
 326  0
                                         aaf.add( artifact.getDependencyFilter() );
 327  0
                                         aaf.add( managedExclusionFilter );
 328  0
                                         artifact.setDependencyFilter( aaf );
 329  0
                                     }
 330  
                                     else
 331  
                                     {
 332  0
                                         artifact.setDependencyFilter( managedExclusionFilter );
 333  
                                     }
 334  
                                 }
 335  
                             }
 336  
 
 337  0
                             if ( artifact.getVersion() == null )
 338  
                             {
 339  
                                 // set the recommended version
 340  
                                 // TODO: maybe its better to just pass the range through to retrieval and use a transformation?
 341  
                                 ArtifactVersion version;
 342  0
                                 if ( artifact.isSelectedVersionKnown() )
 343  
                                 {
 344  0
                                     version = artifact.getSelectedVersion();
 345  
                                 }
 346  
                                 else
 347  
                                 {
 348  
                                     //go find the version
 349  0
                                     List versions = artifact.getAvailableVersions();
 350  0
                                     if ( versions == null )
 351  
                                     {
 352  0
                                         versions = source.retrieveAvailableVersions( artifact, localRepository,
 353  
                                                                                      childRemoteRepositories );
 354  0
                                         artifact.setAvailableVersions( versions );
 355  
                                     }
 356  
 
 357  0
                                     Collections.sort( versions );
 358  
 
 359  0
                                     VersionRange versionRange = artifact.getVersionRange();
 360  
 
 361  0
                                     version = versionRange.matchVersion( versions );
 362  
 
 363  0
                                     if ( version == null )
 364  
                                     {
 365  
                                         // Getting the dependency trail so it can be logged in the exception
 366  0
                                         artifact.setDependencyTrail( node.getDependencyTrail() );
 367  
 
 368  0
                                         if ( versions.isEmpty() )
 369  
                                         {
 370  0
                                             throw new OverConstrainedVersionException(
 371  
                                                 "No versions are present in the repository for the artifact with a range " +
 372  
                                                     versionRange, artifact, childRemoteRepositories );
 373  
                                         }
 374  
 
 375  0
                                         throw new OverConstrainedVersionException( "Couldn't find a version in " +
 376  
                                             versions + " to match range " + versionRange, artifact,
 377  
                                             childRemoteRepositories );
 378  
                                     }
 379  
                                 }
 380  
 
 381  
                                 //this is dangerous because artifact.getSelectedVersion() can
 382  
                                 //return null. However it is ok here because we first check if the
 383  
                                 //selected version is known. As currently coded we can't get a null here.
 384  0
                                 artifact.selectVersion( version.toString() );
 385  0
                                 fireEvent( ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, child );
 386  
                             }
 387  
 
 388  0
                             Artifact relocated = source.retrieveRelocatedArtifact( artifact, localRepository, childRemoteRepositories );
 389  0
                             if ( !artifact.equals( relocated ) )
 390  
                             {
 391  0
                                 relocated.setDependencyFilter( artifact.getDependencyFilter() );
 392  0
                                 artifact = relocated;
 393  0
                                 child.setArtifact( artifact );
 394  
                             }
 395  
                         }
 396  0
                         while( !childKey.equals( child.getKey() ) );
 397  
                         
 398  0
                         if ( parentArtifact != null && parentArtifact.getDependencyFilter() != null && !parentArtifact.getDependencyFilter().include( artifact ) )
 399  
                         {
 400  
                             // MNG-3769: the [probably relocated] artifact is excluded. 
 401  
                             // We could process exclusions on relocated artifact details in the
 402  
                             // MavenMetadataSource.createArtifacts(..) step, BUT that would
 403  
                             // require resolving the POM from the repository very early on in
 404  
                             // the build.
 405  0
                             continue;
 406  
                         }
 407  
 
 408  0
                         artifact.setDependencyTrail( node.getDependencyTrail() );
 409  0
                         ResolutionGroup rGroup = source.retrieve( artifact, localRepository, remoteRepositories );
 410  
 
 411  
                         //TODO might be better to have source.retrieve() throw a specific exception for this situation
 412  
                         //and catch here rather than have it return null
 413  0
                         if ( rGroup == null )
 414  
                         {
 415  
                             //relocated dependency artifact is declared excluded, no need to add and recurse further
 416  0
                             continue;
 417  
                         }
 418  
 
 419  0
                         child.addDependencies( rGroup.getArtifacts(), rGroup.getResolutionRepositories(), filter );
 420  
 
 421  
                     }
 422  0
                     catch ( CyclicDependencyException e )
 423  
                     {
 424  
                         // would like to throw this, but we have crappy stuff in the repo
 425  
 
 426  0
                         fireEvent( ResolutionListener.OMIT_FOR_CYCLE, listeners,
 427  
                                    new ResolutionNode( e.getArtifact(), remoteRepositories, child ) );
 428  
                     }
 429  0
                     catch ( ArtifactMetadataRetrievalException e )
 430  
                     {
 431  0
                         artifact.setDependencyTrail( node.getDependencyTrail() );
 432  0
                         throw new ArtifactResolutionException(
 433  
                             "Unable to get dependency information: " + e.getMessage(), artifact, remoteRepositories,
 434  
                             e );
 435  0
                     }
 436  
 
 437  0
                     recurse( originatingArtifact, child, resolvedArtifacts, managedVersions, localRepository, remoteRepositories, source,
 438  
                              filter, listeners );
 439  
                 }
 440  0
             }
 441  
 
 442  0
             fireEvent( ResolutionListener.FINISH_PROCESSING_CHILDREN, listeners, node );
 443  
         }
 444  0
     }
 445  
 
 446  
     private void manageArtifact( ResolutionNode node, ManagedVersionMap managedVersions, List listeners )
 447  
     {
 448  0
         Artifact artifact = (Artifact) managedVersions.get( node.getKey() );
 449  
 
 450  
         // Before we update the version of the artifact, we need to know
 451  
         // whether we are working on a transitive dependency or not.  This
 452  
         // allows depMgmt to always override transitive dependencies, while
 453  
         // explicit child override depMgmt (viz. depMgmt should only
 454  
         // provide defaults to children, but should override transitives).
 455  
         // We can do this by calling isChildOfRootNode on the current node.
 456  
 
 457  0
         if ( artifact.getVersion() != null
 458  
                         && ( node.isChildOfRootNode() ? node.getArtifact().getVersion() == null : true ) )
 459  
         {
 460  0
             fireEvent( ResolutionListener.MANAGE_ARTIFACT_VERSION, listeners, node, artifact );
 461  0
             node.getArtifact().setVersion( artifact.getVersion() );
 462  
         }
 463  
 
 464  0
         if ( artifact.getScope() != null
 465  
                         && ( node.isChildOfRootNode() ? node.getArtifact().getScope() == null : true ) )
 466  
         {
 467  0
             fireEvent( ResolutionListener.MANAGE_ARTIFACT_SCOPE, listeners, node, artifact );
 468  0
             node.getArtifact().setScope( artifact.getScope() );
 469  
         }
 470  0
     }
 471  
 
 472  
     /**
 473  
      * Check if the scope needs to be updated.
 474  
      * <a href="http://docs.codehaus.org/x/IGU#DependencyMediationandConflictResolution-Scoperesolution">More info</a>.
 475  
      *
 476  
      * @param farthest  farthest resolution node
 477  
      * @param nearest   nearest resolution node
 478  
      * @param listeners
 479  
      */
 480  
     boolean checkScopeUpdate( ResolutionNode farthest, ResolutionNode nearest, List listeners )
 481  
     {
 482  0
         boolean updateScope = false;
 483  0
         Artifact farthestArtifact = farthest.getArtifact();
 484  0
         Artifact nearestArtifact = nearest.getArtifact();
 485  
 
 486  
         /* farthest is runtime and nearest has lower priority, change to runtime */
 487  0
         if ( Artifact.SCOPE_RUNTIME.equals( farthestArtifact.getScope() ) && (
 488  
             Artifact.SCOPE_TEST.equals( nearestArtifact.getScope() ) ||
 489  
                 Artifact.SCOPE_PROVIDED.equals( nearestArtifact.getScope() ) ) )
 490  
         {
 491  0
             updateScope = true;
 492  
         }
 493  
 
 494  
         /* farthest is compile and nearest is not (has lower priority), change to compile */
 495  0
         if ( Artifact.SCOPE_COMPILE.equals( farthestArtifact.getScope() ) &&
 496  
             !Artifact.SCOPE_COMPILE.equals( nearestArtifact.getScope() ) )
 497  
         {
 498  0
             updateScope = true;
 499  
         }
 500  
 
 501  
         /* current POM rules all, if nearest is in current pom, do not update its scope */
 502  0
         if ( nearest.getDepth() < 2 && updateScope )
 503  
         {
 504  0
             updateScope = false;
 505  
 
 506  0
             fireEvent( ResolutionListener.UPDATE_SCOPE_CURRENT_POM, listeners, nearest, farthestArtifact );
 507  
         }
 508  
 
 509  0
         if ( updateScope )
 510  
         {
 511  0
             fireEvent( ResolutionListener.UPDATE_SCOPE, listeners, nearest, farthestArtifact );
 512  
 
 513  
             // previously we cloned the artifact, but it is more effecient to just update the scope
 514  
             // if problems are later discovered that the original object needs its original scope value, cloning may
 515  
             // again be appropriate
 516  0
             nearestArtifact.setScope( farthestArtifact.getScope() );
 517  
         }
 518  
 
 519  0
         return updateScope;
 520  
     }
 521  
 
 522  
     private void fireEvent( int event, List listeners, ResolutionNode node )
 523  
     {
 524  0
         fireEvent( event, listeners, node, null );
 525  0
     }
 526  
 
 527  
     private void fireEvent( int event, List listeners, ResolutionNode node, Artifact replacement )
 528  
     {
 529  0
         fireEvent( event, listeners, node, replacement, null );
 530  0
     }
 531  
 
 532  
     private void fireEvent( int event, List listeners, ResolutionNode node, Artifact replacement,
 533  
                             VersionRange newRange )
 534  
     {
 535  0
         for ( Iterator i = listeners.iterator(); i.hasNext(); )
 536  
         {
 537  0
             ResolutionListener listener = (ResolutionListener) i.next();
 538  
 
 539  0
             switch ( event )
 540  
             {
 541  
                 case ResolutionListener.TEST_ARTIFACT:
 542  0
                     listener.testArtifact( node.getArtifact() );
 543  0
                     break;
 544  
                 case ResolutionListener.PROCESS_CHILDREN:
 545  0
                     listener.startProcessChildren( node.getArtifact() );
 546  0
                     break;
 547  
                 case ResolutionListener.FINISH_PROCESSING_CHILDREN:
 548  0
                     listener.endProcessChildren( node.getArtifact() );
 549  0
                     break;
 550  
                 case ResolutionListener.INCLUDE_ARTIFACT:
 551  0
                     listener.includeArtifact( node.getArtifact() );
 552  0
                     break;
 553  
                 case ResolutionListener.OMIT_FOR_NEARER:
 554  0
                     listener.omitForNearer( node.getArtifact(), replacement );
 555  0
                     break;
 556  
                 case ResolutionListener.OMIT_FOR_CYCLE:
 557  0
                     listener.omitForCycle( node.getArtifact() );
 558  0
                     break;
 559  
                 case ResolutionListener.UPDATE_SCOPE:
 560  0
                     listener.updateScope( node.getArtifact(), replacement.getScope() );
 561  0
                     break;
 562  
                 case ResolutionListener.UPDATE_SCOPE_CURRENT_POM:
 563  0
                     listener.updateScopeCurrentPom( node.getArtifact(), replacement.getScope() );
 564  0
                     break;
 565  
                 case ResolutionListener.MANAGE_ARTIFACT_VERSION:
 566  0
                     if (listener instanceof ResolutionListenerForDepMgmt) {
 567  0
                         ResolutionListenerForDepMgmt asImpl = (ResolutionListenerForDepMgmt) listener;
 568  0
                         asImpl.manageArtifactVersion( node.getArtifact(), replacement );
 569  0
                     } else {
 570  0
                         listener.manageArtifact( node.getArtifact(), replacement );
 571  
                     }
 572  0
                     break;
 573  
                 case ResolutionListener.MANAGE_ARTIFACT_SCOPE:
 574  0
                     if (listener instanceof ResolutionListenerForDepMgmt) {
 575  0
                         ResolutionListenerForDepMgmt asImpl = (ResolutionListenerForDepMgmt) listener;
 576  0
                         asImpl.manageArtifactScope( node.getArtifact(), replacement );
 577  0
                     } else {
 578  0
                         listener.manageArtifact( node.getArtifact(), replacement );
 579  
                     }
 580  0
                     break;
 581  
                 case ResolutionListener.SELECT_VERSION_FROM_RANGE:
 582  0
                     listener.selectVersionFromRange( node.getArtifact() );
 583  0
                     break;
 584  
                 case ResolutionListener.RESTRICT_RANGE:
 585  0
                     if ( node.getArtifact().getVersionRange().hasRestrictions() ||
 586  
                         replacement.getVersionRange().hasRestrictions() )
 587  
                     {
 588  0
                         listener.restrictRange( node.getArtifact(), replacement, newRange );
 589  
                     }
 590  
                     break;
 591  
                 default:
 592  0
                     throw new IllegalStateException( "Unknown event: " + event );
 593  
             }
 594  0
         }
 595  0
     }
 596  
 
 597  
 }