protected ArtifactResolutionResult doExecuteResolution()

in src/main/java/org/apache/maven/artifact/ant/DependenciesTask.java [171:399]
185 lines of code
32 McCabe index (conditional complexity)

    protected ArtifactResolutionResult doExecuteResolution()
    {
        ArtifactRepository localRepo = createLocalArtifactRepository();
        log( "Using local repository: " + localRepo.getBasedir(), Project.MSG_VERBOSE );

        // Look up required resources from the plexus container
        ArtifactResolver resolver = (ArtifactResolver) lookup( ArtifactResolver.ROLE );
        ArtifactFactory artifactFactory = (ArtifactFactory) lookup( ArtifactFactory.ROLE );
        MavenMetadataSource metadataSource = (MavenMetadataSource) lookup( ArtifactMetadataSource.ROLE );

        Pom pom = initializePom( localRepo );
        if ( pom != null )
        {
            dependencies = pom.getDependencies();
        }
        else
        {
            // we have to have some sort of Pom object in order to satisfy the requirements for building the
            // originating Artifact below...
            pom = createDummyPom( localRepo );
        }

        if ( dependencies.isEmpty() )
        {
            log( "There were no dependencies specified", Project.MSG_WARN );
        }
        else
        {
            // check scopes
            for ( Dependency dependency : dependencies )
            {
                String scope = dependency.getScope();

                if ( Artifact.SCOPE_SYSTEM.equals( scope ) )
                {
                    if ( StringUtils.isBlank( dependency.getSystemPath() ) )
                    {
                        throw new BuildException( dependency.toString()
                            + " is defined with scope='system': systemPath attribute is required." );
                    }
                }
                else if ( ( scope != null ) && !SCOPES_SET.contains( scope ) )
                {
                    // see MANTTASKS-190
                    log( "Unknown scope='" + scope + "' for " + dependency + ", supported scopes are: " + SCOPES_SET,
                         Project.MSG_WARN );
                }
            }
        }

        log( "Resolving dependencies...", Project.MSG_VERBOSE );

        ArtifactResolutionResult result;

        List<ArtifactRepository> remoteArtifactRepositories = createRemoteArtifactRepositories( pom.getRepositories() );

        try
        {
            Set<Artifact> artifacts = MavenMetadataSource.createArtifacts( artifactFactory, dependencies, null, null, null );

            Artifact pomArtifact = artifactFactory.createBuildArtifact( pom.getGroupId(), pom.getArtifactId(),
                pom.getVersion(), pom.getPackaging() );

            List<AntResolutionListener> listeners = Collections.singletonList( new AntResolutionListener( getProject() ) );

            Map<String,Artifact> managedDependencies = pom.getMavenProject().getManagedVersionMap();

            ArtifactFilter filter = null;
            if ( useScope != null )
            {
                filter = new ScopeArtifactFilter( useScope );
            }
            if ( scopes != null )
            {
                filter = new SpecificScopesArtifactFilter( scopes );
            }
            if ( type != null )
            {
                ArtifactFilter typeArtifactFilter = new TypesArtifactFilter( type );
                if ( filter != null )
                {
                    AndArtifactFilter andFilter = new AndArtifactFilter();
                    andFilter.add( filter );
                    andFilter.add( typeArtifactFilter );
                    filter = andFilter;
                }
                else
                {
                    filter = typeArtifactFilter;
                }
            }

            result = resolver.resolveTransitively( artifacts, pomArtifact, managedDependencies, localRepo,
                                                   remoteArtifactRepositories, metadataSource, filter, listeners );
        }
        catch ( ArtifactResolutionException e )
        {
            throw new BuildException( "Unable to resolve artifact: " + e.getMessage(), e );
        }
        catch ( ArtifactNotFoundException e )
        {
            throw new BuildException( "Dependency not found: " + e.getMessage(), e );
        }
        catch ( InvalidDependencyVersionException e )
        {
            throw new BuildException( "Invalid dependency version: " + e.getMessage(), e );
        }

        FileSet dependencyFileSet = createFileSet();

        FileSet sourcesFileSet = createFileSet();

        FileSet javadocsFileSet = createFileSet();

        Path dependencyPath = new Path( getProject() );

        Set<String> versions = new HashSet<String>();

        ArtifactFilter pathFilter;

        if ( pathType  != null )
        {
            pathFilter = new TypesArtifactFilter( pathType );
        }
        else
        {
            pathFilter = null;
        }

        for ( Iterator<Artifact> i = result.getArtifacts().iterator(); i.hasNext(); )
        {
            Artifact artifact = i.next();

            addArtifactToResult( localRepo, artifact, dependencyFileSet, dependencyPath, pathFilter );

            versions.add( artifact.getVersion() );

            if ( sourcesFilesetId != null )
            {
                resolveSource( artifactFactory, resolver, remoteArtifactRepositories, localRepo,
                               artifact, "sources", sourcesFileSet );
            }

            if ( javadocFilesetId != null )
            {
                resolveSource( artifactFactory, resolver, remoteArtifactRepositories, localRepo,
                               artifact, "javadoc", javadocsFileSet );
            }

        }

        defineFilesetReference( filesetId, dependencyFileSet );

        defineFilesetReference( sourcesFilesetId, sourcesFileSet );

        defineFilesetReference( javadocFilesetId, javadocsFileSet );

        if ( pathId != null )
        {
            getProject().addReference( pathId, dependencyPath );
        }

        if ( versionsId != null )
        {
            String versionsValue = StringUtils.join( versions.iterator(), File.pathSeparator );
            getProject().setNewProperty( versionsId, versionsValue );
        }

        // Write the dependency information to an Ant build file.
        if ( getDependencyRefsBuildFile() != null || this.isCacheDependencyRefs() )
        {
            if ( getDependencyRefsBuildFile() == null || getDependencyRefsBuildFile().equals( "default" ) )
            {
                setDependencyRefsBuildFile( DEFAULT_ANT_BUILD_FILE );
            }
            log( "Building ant file: " + getDependencyRefsBuildFile() );
            AntBuildWriter antBuildWriter = new AntBuildWriter();
            File antBuildFile = FileUtils.resolveFile( getProject().getBaseDir(), getDependencyRefsBuildFile() );
            try
            {
                antBuildWriter.openAntBuild( antBuildFile, "maven-dependencies", "init-dependencies" );
                antBuildWriter.openTarget( "init-dependencies" );
                antBuildWriter.writeEcho( "Loading dependency paths from file: " + antBuildFile.getAbsolutePath() );

                for ( Iterator<Artifact> i = result.getArtifacts().iterator(); i.hasNext(); )
                {
                    Artifact artifact = i.next();
                    String conflictId = artifact.getDependencyConflictId();
                    antBuildWriter.writeProperty( conflictId, artifact.getFile().getAbsolutePath() );
                    FileSet singleArtifactFileSet = (FileSet) getProject().getReference( conflictId );
                    antBuildWriter.writeFileSet( singleArtifactFileSet, conflictId );
                }

                if ( pathId != null )
                {
                    Path thePath = (Path) getProject().getReference( pathId );
                    antBuildWriter.writePath( thePath, pathId );
                }

                if ( filesetId != null )
                {
                    antBuildWriter.writeFileSet( dependencyFileSet, filesetId );
                }
                if ( sourcesFilesetId != null )
                {
                    antBuildWriter.writeFileSet( sourcesFileSet, sourcesFilesetId );
                }
                if ( javadocFilesetId != null )
                {
                    antBuildWriter.writeFileSet( sourcesFileSet, javadocFilesetId );
                }

                String versionsList = getProject().getProperty( versionsId );
                if ( versionsList != null )
                {
                    antBuildWriter.writeProperty( versionsId, versionsList );
                }

                antBuildWriter.closeTarget();
                antBuildWriter.closeAntBuild();
            }
            catch ( IOException e )
            {
                throw new BuildException ( "Unable to write ant build: " + e);
            }
        }

        return result;
    }