* 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.

*/

    extends AbstractLogEnabled

    implements PluginManager, Initializable, Contextualizable

    protected PlexusContainer container;

    protected PluginDescriptorBuilder pluginDescriptorBuilder;

    protected ArtifactFilter artifactFilter;

    private Log mojoLogger;

    private Map resolvedCoreArtifactFiles = new HashMap();

    // component requirements

    protected PathTranslator pathTranslator;

    protected MavenPluginCollector pluginCollector;

    protected PluginVersionManager pluginVersionManager;

    protected ArtifactFactory artifactFactory;

    protected ArtifactResolver artifactResolver;

    protected ArtifactMetadataSource artifactMetadataSource;

    protected RuntimeInformation runtimeInformation;

    protected MavenProjectBuilder mavenProjectBuilder;

   

    protected PluginMappingManager pluginMappingManager;

    // END component requirements

    public DefaultPluginManager()

    {

        pluginDescriptorBuilder = new PluginDescriptorBuilder();

    }

    // ----------------------------------------------------------------------

    //

    // ----------------------------------------------------------------------

    public PluginDescriptor getPluginDescriptorForPrefix( String prefix )

    {

        return pluginCollector.getPluginDescriptorForPrefix( prefix );

    }

    public Plugin getPluginDefinitionForPrefix( String prefix,

                                                MavenSession session,

                                                MavenProject project )

    {

        // TODO: since this is only used in the lifecycle executor, maybe it should be moved there? There is no other

        // use for the mapping manager in here

        return pluginMappingManager.getByPrefix( prefix, session.getSettings().getPluginGroups(),

                                                 project.getPluginArtifactRepositories(),

                                                 session.getLocalRepository() );

    }

    public PluginDescriptor verifyPlugin( Plugin plugin,

                                          MavenProject project,

                                          Settings settings,

                                          ArtifactRepository localRepository )

        throws ArtifactResolutionException, PluginVersionResolutionException, ArtifactNotFoundException,

        InvalidVersionSpecificationException, InvalidPluginException, PluginManagerException, PluginNotFoundException,

        PluginVersionNotFoundException

    {

        // TODO: this should be possibly outside

        // All version-resolution logic has been moved to DefaultPluginVersionManager.

        if ( plugin.getVersion() == null )

        {

            String version = pluginVersionManager.resolvePluginVersion( plugin.getGroupId(), plugin.getArtifactId(),

                                                                        project, settings, localRepository );

            plugin.setVersion( version );

        }

        return verifyVersionedPlugin( plugin, project, localRepository );

    }

    private PluginDescriptor verifyVersionedPlugin( Plugin plugin,

                                                    MavenProject project,

                                                    ArtifactRepository localRepository )

        throws PluginVersionResolutionException, ArtifactNotFoundException, ArtifactResolutionException,

        InvalidVersionSpecificationException, InvalidPluginException, PluginManagerException, PluginNotFoundException

    {

        // TODO: this might result in an artifact "RELEASE" being resolved continuously

        // FIXME: need to find out how a plugin gets marked as 'installed'

        // and no ChildContainer exists. The check for that below fixes

        // the 'Can't find plexus container for plugin: xxx' error.

        try

        {

            VersionRange versionRange = VersionRange.createFromVersionSpec( plugin.getVersion() );

            List remoteRepositories = new ArrayList();

            remoteRepositories.addAll( project.getPluginArtifactRepositories() );

            remoteRepositories.addAll( project.getRemoteArtifactRepositories() );

            checkRequiredMavenVersion( plugin, localRepository, remoteRepositories );

            Artifact pluginArtifact =

                artifactFactory.createPluginArtifact( plugin.getGroupId(), plugin.getArtifactId(), versionRange );

            pluginArtifact = project.replaceWithActiveArtifact( pluginArtifact );

            artifactResolver.resolve( pluginArtifact, project.getPluginArtifactRepositories(), localRepository );

            plugin.setVersion( pluginArtifact.getBaseVersion() );

            String pluginKey = PluginUtils.constructVersionedKey( plugin );

            PlexusContainer pluginContainer = container.getChildContainer( pluginKey );

            File pluginFile = pluginArtifact.getFile();

            if ( !pluginCollector.isPluginInstalled( plugin ) || ( pluginContainer == null ) )

            {

                addPlugin( plugin, pluginArtifact, project, localRepository );

            }

            else if ( pluginFile.lastModified() > pluginContainer.getCreationDate().getTime() )

            {

                getLogger().info(

                    "Reloading plugin container for: " + pluginKey + ". The plugin artifact has changed." );

                pluginContainer.dispose();

                pluginCollector.flushPluginDescriptor( plugin );

                addPlugin( plugin, pluginArtifact, project, localRepository );

            }

            project.addPlugin( plugin );

        }

        catch ( ArtifactNotFoundException e )

        {

            String groupId = plugin.getGroupId();

            String artifactId = plugin.getArtifactId();

            String version = plugin.getVersion();

            if ( ( groupId == null ) || ( artifactId == null ) || ( version == null ) )

            {

                throw new PluginNotFoundException( e );

            }

            else if ( groupId.equals( e.getGroupId() ) && artifactId.equals( e.getArtifactId() ) &&

                version.equals( e.getVersion() ) && "maven-plugin".equals( e.getType() ) )

            {

                throw new PluginNotFoundException( e );

            }

            else

            {

                throw e;

            }

        }

        return pluginCollector.getPluginDescriptor( plugin );

    }

    /**

     * @todo would be better to store this in the plugin descriptor, but then it won't be available to the version

     * manager which executes before the plugin is instantiated

     */

    private void checkRequiredMavenVersion( Plugin plugin,

                                            ArtifactRepository localRepository,

                                            List remoteRepositories )

        throws PluginVersionResolutionException, InvalidPluginException

    {

        try

        {

            Artifact artifact = artifactFactory.createProjectArtifact( plugin.getGroupId(), plugin.getArtifactId(),

                                                                       plugin.getVersion() );

            MavenProject project =

                mavenProjectBuilder.buildFromRepository( artifact, remoteRepositories, localRepository, false );

            // if we don't have the required Maven version, then ignore an update

            if ( ( project.getPrerequisites() != null ) && ( project.getPrerequisites().getMaven() != null ) )

            {

                DefaultArtifactVersion requiredVersion =

                    new DefaultArtifactVersion( project.getPrerequisites().getMaven() );

                if ( runtimeInformation.getApplicationVersion().compareTo( requiredVersion ) < 0 )

                {

                    throw new PluginVersionResolutionException( plugin.getGroupId(), plugin.getArtifactId(),

                                                                "Plugin requires Maven version " + requiredVersion );

                }

            }

        }

        catch ( ProjectBuildingException e )

        {

            throw new InvalidPluginException(

                "Unable to build project for plugin '" + plugin.getKey() + "': " + e.getMessage(), e );

        }

    }

    protected void addPlugin( Plugin plugin,

                              Artifact pluginArtifact,

                              MavenProject project,

                              ArtifactRepository localRepository )

        throws PluginManagerException, InvalidPluginException

    {

        PlexusContainer child;

        try

        {

            MavenPluginValidator validator = new MavenPluginValidator( pluginArtifact );

            String key = PluginUtils.constructVersionedKey( plugin ).intern();

            child = container.createChildContainer( key,

                                                    Collections.singletonList( pluginArtifact.getFile() ),

                                                    Collections.EMPTY_MAP,

                                                    Arrays.asList( new ComponentDiscoveryListener[] { validator, pluginCollector } ) );

            // remove listeners for efficiency since they are only needed for the initial stage and

            // should not be applied to the plugin's dependencies

            child.removeComponentDiscoveryListener( validator );

            child.removeComponentDiscoveryListener( pluginCollector );

            if ( validator.hasErrors() )

            {

                String msg = "Plugin '" + key + "' has an invalid descriptor:";

                int count = 1;

                for ( Iterator i = validator.getErrors().iterator(); i.hasNext(); )

                {

                    msg += "\n" + count + ") " + i.next();

                    count++;

                }

                throw new PluginManagerException( msg );

            }

            try

            {

                child.getContainerRealm().importFrom( "plexus.core", "org.codehaus.plexus.util.xml.Xpp3Dom" );

                child.getContainerRealm().importFrom( "plexus.core", "org.codehaus.plexus.util.xml.pull.XmlPullParser" );

                child.getContainerRealm().importFrom( "plexus.core", "org.codehaus.plexus.util.xml.pull.XmlPullParserException" );

                child.getContainerRealm().importFrom( "plexus.core", "org.codehaus.plexus.util.xml.pull.XmlSerializer" );

                // MNG-2878

                child.getContainerRealm().importFrom( "plexus.core", "/default-report.xml" );

            }

            catch ( NoSuchRealmException e )

            {

                // won't happen

            }

        }

        catch ( PlexusContainerException e )

        {

            throw new PluginManagerException(

                "Failed to create plugin container for plugin '" + plugin + "': " + e.getMessage(), e );

        }

        // this plugin's descriptor should have been discovered in the child creation, so we should be able to

        // circle around and set the artifacts and class realm

        PluginDescriptor addedPlugin = pluginCollector.getPluginDescriptor( plugin );

        if ( addedPlugin == null )

        {

            throw new IllegalStateException( "The plugin descriptor for the plugin " + plugin + " was not found."

                + " Please verify that the plugin JAR " + pluginArtifact.getFile() + " is intact." );

        }

        addedPlugin.setClassRealm( child.getContainerRealm() );

        // we're only setting the plugin's artifact itself as the artifact list, to allow it to be retrieved

        // later when the plugin is first invoked. Retrieving this artifact will in turn allow us to

        // transitively resolve its dependencies, and add them to the plugin container...

        addedPlugin.setArtifacts( Collections.singletonList( pluginArtifact ) );

        addedPlugin.setPluginArtifact( pluginArtifact );

        try

        {

            // the only Plugin instance which will have dependencies is the one specified in the project.

            // We need to look for a Plugin instance there, in case the instance we're using didn't come from

            // the project.

            Plugin projectPlugin = (Plugin) project.getBuild().getPluginsAsMap().get( plugin.getKey() );

            if ( projectPlugin == null )

            {

                projectPlugin = plugin;

            }

            Set artifacts = MavenMetadataSource.createArtifacts( artifactFactory, projectPlugin.getDependencies(), null,

                                                                 null, project );

//                MavenMetadataSource.createArtifacts( artifactFactory, plugin.getDependencies(), null, null, project );

            addedPlugin.setIntroducedDependencyArtifacts( artifacts );

        }

        catch ( InvalidDependencyVersionException e )

        {

            throw new InvalidPluginException( "Plugin '" + plugin + "' is invalid: " + e.getMessage(), e );

        }

    }

    // ----------------------------------------------------------------------

    // Mojo execution

    // ----------------------------------------------------------------------

    public void executeMojo( MavenProject project,

                             MojoExecution mojoExecution,

                             MavenSession session )

        throws ArtifactResolutionException, MojoExecutionException, MojoFailureException, ArtifactNotFoundException,

        InvalidDependencyVersionException, PluginManagerException, PluginConfigurationException

    {

        MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();

        // NOTE: I'm putting these checks in here, since this is the central point of access for

        // anything that wants to execute a mojo.

        if ( mojoDescriptor.isProjectRequired() && !session.isUsingPOMsFromFilesystem() )

        {

            throw new MojoExecutionException( "Cannot execute mojo: " + mojoDescriptor.getGoal() +

                ". It requires a project with an existing pom.xml, but the build is not using one." );

        }

        if ( mojoDescriptor.isOnlineRequired() && session.getSettings().isOffline() )

        {

            // TODO: Should we error out, or simply warn and skip??

            throw new MojoExecutionException( "Mojo: " + mojoDescriptor.getGoal() +

                " requires online mode for execution. Maven is currently offline." );

        }

        if ( mojoDescriptor.isDependencyResolutionRequired() != null )

        {

            Collection projects;

            if ( mojoDescriptor.isAggregator() )

            {

                projects = session.getSortedProjects();

            }

            else

            {

                projects = Collections.singleton( project );

            }

            for ( Iterator i = projects.iterator(); i.hasNext(); )

            {

                MavenProject p = (MavenProject) i.next();

                resolveTransitiveDependencies( session, artifactResolver,

                                               mojoDescriptor.isDependencyResolutionRequired(), artifactFactory, p, mojoDescriptor.isAggregator() );

            }

            downloadDependencies( project, session, artifactResolver );

        }

        String goalName = mojoDescriptor.getFullGoalName();

        Mojo plugin;

        PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();

        String goalId = mojoDescriptor.getGoal();

        String groupId = pluginDescriptor.getGroupId();

        String artifactId = pluginDescriptor.getArtifactId();

        String executionId = mojoExecution.getExecutionId();

        Xpp3Dom dom = project.getGoalConfiguration( groupId, artifactId, executionId, goalId );

        Xpp3Dom reportDom = project.getReportConfiguration( groupId, artifactId, executionId );

        dom = Xpp3Dom.mergeXpp3Dom( dom, reportDom );

        if ( mojoExecution.getConfiguration() != null )

        {

            dom = Xpp3Dom.mergeXpp3Dom( dom, mojoExecution.getConfiguration() );

        }

        plugin = getConfiguredMojo( session, dom, project, false, mojoExecution );

        // Event monitoring.

        String event = MavenEvents.MOJO_EXECUTION;

        EventDispatcher dispatcher = session.getEventDispatcher();

        String goalExecId = goalName;

        if ( mojoExecution.getExecutionId() != null )

        {

            goalExecId += " {execution: " + mojoExecution.getExecutionId() + "}";

        }

        dispatcher.dispatchStart( event, goalExecId );

        ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();

        try

        {

            Thread.currentThread().setContextClassLoader(

                mojoDescriptor.getPluginDescriptor().getClassRealm().getClassLoader() );

            plugin.execute();

            dispatcher.dispatchEnd( event, goalExecId );

        }

        catch ( MojoExecutionException e )

        {

            session.getEventDispatcher().dispatchError( event, goalExecId, e );

            throw e;

        }

        catch ( MojoFailureException e )

        {

            session.getEventDispatcher().dispatchError( event, goalExecId, e );

            throw e;

        }

        catch ( LinkageError e )

        {

            if ( getLogger().isFatalErrorEnabled() )

            {

                getLogger().fatalError(

                                        plugin.getClass().getName() + "#execute() caused a linkage error ("

                                            + e.getClass().getName() + ") and may be out-of-date. Check the realms:" );

                ClassRealm pluginRealm = mojoDescriptor.getPluginDescriptor().getClassRealm();

                StringBuffer sb = new StringBuffer();

                sb.append( "Plugin realm = " + pluginRealm.getId() ).append( '\n' );

                for ( int i = 0; i < pluginRealm.getConstituents().length; i++ )

                {

                    sb.append( "urls[" + i + "] = " + pluginRealm.getConstituents()[i] );

                    if ( i != ( pluginRealm.getConstituents().length - 1 ) )

                    {

                        sb.append( '\n' );

                    }

                }

                getLogger().fatalError( sb.toString() );

                ClassRealm containerRealm = container.getContainerRealm();

                sb = new StringBuffer();

                sb.append( "Container realm = " + containerRealm.getId() ).append( '\n' );

                for ( int i = 0; i < containerRealm.getConstituents().length; i++ )

                {

                    sb.append( "urls[" + i + "] = " + containerRealm.getConstituents()[i] );

                    if ( i != ( containerRealm.getConstituents().length - 1 ) )

                    {

                        sb.append( '\n' );

                    }

                }

                getLogger().fatalError( sb.toString() );

            }

            session.getEventDispatcher().dispatchError( event, goalExecId, e );

            throw e;

        }

        finally

        {

            Thread.currentThread().setContextClassLoader( oldClassLoader );

            try

            {

                PlexusContainer pluginContainer = getPluginContainer( mojoDescriptor.getPluginDescriptor() );

                pluginContainer.release( plugin );

            }

            catch ( ComponentLifecycleException e )

            {

                if ( getLogger().isErrorEnabled() )

                {

                    getLogger().error( "Error releasing plugin - ignoring.", e );

                }

            }

        }

    }

    public MavenReport getReport( MavenProject project,

                                  MojoExecution mojoExecution,

                                  MavenSession session )

        throws ArtifactNotFoundException, PluginConfigurationException, PluginManagerException,

        ArtifactResolutionException

    {

        MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();

        PluginDescriptor descriptor = mojoDescriptor.getPluginDescriptor();

        Xpp3Dom dom = project.getReportConfiguration( descriptor.getGroupId(), descriptor.getArtifactId(),

                                                      mojoExecution.getExecutionId() );

        if ( mojoExecution.getConfiguration() != null )

        {

            dom = Xpp3Dom.mergeXpp3Dom( dom, mojoExecution.getConfiguration() );

        }

        MavenReport report = (MavenReport) getConfiguredMojo( session, dom, project, true, mojoExecution );

       

        return report;

    }

    public PluginDescriptor verifyReportPlugin( ReportPlugin reportPlugin,

                                                MavenProject project,

                                                MavenSession session )

        throws PluginVersionResolutionException, ArtifactResolutionException, ArtifactNotFoundException,

        InvalidVersionSpecificationException, InvalidPluginException, PluginManagerException, PluginNotFoundException,

        PluginVersionNotFoundException

    {

        String version = reportPlugin.getVersion();

        if ( version == null )

        {

            version = pluginVersionManager.resolveReportPluginVersion( reportPlugin.getGroupId(),

                                                                       reportPlugin.getArtifactId(), project,

                                                                       session.getSettings(),

                                                                       session.getLocalRepository() );

            reportPlugin.setVersion( version );

        }

        Plugin forLookup = new Plugin();

        forLookup.setGroupId( reportPlugin.getGroupId() );

        forLookup.setArtifactId( reportPlugin.getArtifactId() );

        forLookup.setVersion( version );

        return verifyVersionedPlugin( forLookup, project, session.getLocalRepository() );

    }

    private PlexusContainer getPluginContainer( PluginDescriptor pluginDescriptor )

        throws PluginManagerException

    {

        String pluginKey = PluginUtils.constructVersionedKey( pluginDescriptor );

        PlexusContainer pluginContainer = container.getChildContainer( pluginKey );

        if ( pluginContainer == null )

        {

            throw new PluginManagerException( "Cannot find Plexus container for plugin: " + pluginKey );

        }

        return pluginContainer;

    }

    private Mojo getConfiguredMojo( MavenSession session,

                                    Xpp3Dom dom,

                                    MavenProject project,

                                    boolean report,

                                    MojoExecution mojoExecution )

        throws PluginConfigurationException, ArtifactNotFoundException, PluginManagerException,

        ArtifactResolutionException

    {

        MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();

        PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();

        PlexusContainer pluginContainer = getPluginContainer( pluginDescriptor );

        // if this is the first time this plugin has been used, the plugin's container will only

        // contain the plugin's artifact in isolation; we need to finish resolving the plugin's

        // dependencies, and add them to the container.

        ensurePluginContainerIsComplete( pluginDescriptor, pluginContainer, project, session );

        Mojo plugin;

        try

        {

            plugin = (Mojo) pluginContainer.lookup( Mojo.ROLE, mojoDescriptor.getRoleHint() );

            if ( report && !( plugin instanceof MavenReport ) )

            {

                // TODO: the mojoDescriptor should actually capture this information so we don't get this far

                return null;

            }

        }

        catch ( ComponentLookupException e )

        {

            Throwable cause = e.getCause();

            while( cause != null && !(cause instanceof NoClassDefFoundError ) )

            {

                cause = cause.getCause();

            }

           

            if ( cause != null && ( cause instanceof NoClassDefFoundError ) )

            {

                throw new PluginManagerException( "Unable to load the mojo '" + mojoDescriptor.getRoleHint()

                                                  + "' in the plugin '" + pluginDescriptor.getPluginLookupKey() + "'. A required class is missing: "

                                                  + cause.getMessage(), e );

            }

           

            throw new PluginManagerException( "Unable to find the mojo '" + mojoDescriptor.getGoal() +

                "' (or one of its required components) in the plugin '" + pluginDescriptor.getPluginLookupKey() + "'", e );

        }

        catch ( NoClassDefFoundError e )

        {

            throw new PluginManagerException( "Unable to load the mojo '" + mojoDescriptor.getRoleHint()

                + "' in the plugin '" + pluginDescriptor.getPluginLookupKey() + "'. A required class is missing: "

                + e.getMessage(), e );

        }

        if ( plugin instanceof ContextEnabled )

        {

            Map pluginContext = session.getPluginContext( pluginDescriptor, project );

            ( (ContextEnabled) plugin ).setPluginContext( pluginContext );

        }

        plugin.setLog( mojoLogger );

        XmlPlexusConfiguration pomConfiguration;

        if ( dom == null )

        {

            pomConfiguration = new XmlPlexusConfiguration( "configuration" );

        }

        else

        {

            pomConfiguration = new XmlPlexusConfiguration( dom );

        }

        // Validate against non-editable (@readonly) parameters, to make sure users aren't trying to

        // override in the POM.

        validatePomConfiguration( mojoDescriptor, pomConfiguration );

        PlexusConfiguration mergedConfiguration = mergeMojoConfiguration( pomConfiguration, mojoDescriptor );

        // TODO: plexus changes to make this more like the component descriptor so this can be used instead

        //            PlexusConfiguration mergedConfiguration = mergeConfiguration( pomConfiguration,

        //                                                                          mojoDescriptor.getConfiguration() );

        ExpressionEvaluator expressionEvaluator = new PluginParameterExpressionEvaluator( session, mojoExecution,

                                                                                          pathTranslator,

                                                                                          getLogger(),

                                                                                          project,

                                                                                          session.getExecutionProperties() );

        PlexusConfiguration extractedMojoConfiguration =

            extractMojoConfiguration( mergedConfiguration, mojoDescriptor );

        checkRequiredParameters( mojoDescriptor, extractedMojoConfiguration, expressionEvaluator );

        populatePluginFields( plugin, mojoDescriptor, extractedMojoConfiguration, pluginContainer,

                              expressionEvaluator );

        return plugin;

    }

    private void ensurePluginContainerIsComplete( PluginDescriptor pluginDescriptor,

                                                  PlexusContainer pluginContainer,

                                                  MavenProject project,

                                                  MavenSession session )

        throws ArtifactNotFoundException, PluginManagerException, ArtifactResolutionException

    {

        // if the plugin's already been used once, don't re-do this step...

        // otherwise, we have to finish resolving the plugin's classpath and start the container.

        if ( ( pluginDescriptor.getArtifacts() != null ) && ( pluginDescriptor.getArtifacts().size() == 1 ) )

        {

            Artifact pluginArtifact = (Artifact) pluginDescriptor.getArtifacts().get( 0 );

            ArtifactRepository localRepository = session.getLocalRepository();

            ResolutionGroup resolutionGroup;

            try

            {

                resolutionGroup = artifactMetadataSource.retrieve( pluginArtifact, localRepository,

                                                                   project.getPluginArtifactRepositories() );

            }

            catch ( ArtifactMetadataRetrievalException e )

            {

                throw new ArtifactResolutionException( "Unable to download metadata from repository for plugin '" +

                    pluginArtifact.getId() + "': " + e.getMessage(), pluginArtifact, e );

            }

            Set rgArtifacts = resolutionGroup.getArtifacts();

            rgArtifacts = checkPlexusUtils( rgArtifacts, artifactFactory );

            // [jdcasey; 20-March-2008]:

            // This is meant to eliminate the introduction of duplicated artifacts.

            // Since much of the reasoning for reversing the order of introduction of

            // plugin dependencies rests on the notion that we need to be able to

            // introduce upgraded versions of plugin dependencies on a case-by-case

            // basis, we need to remove the original version prior to artifact

            // resolution. This is consistent with recent thinking on duplicated

            // dependency specifications within a POM, where that case should

            // throw a model validation exception.

            //

            // Here, we just want to remove any chance that the ArtifactCollector

            // could make a bad choice, and use the old version in spite of our

            // explicit preference otherwise.

            // First, we're going to accumulate plugin dependencies in an ordered map,

            // keyed by dependencyConflictId (the ordered map is meant to preserve relative

            // ordering of the dependencies that do make the cut).

            Map dependencyMap = new LinkedHashMap();

            // Next, we need to accumulate all dependencies in a List, to make it

            // simpler to iterate through them all and add them to the map.

            List all = new ArrayList();

            // plugin-level dependencies from the consuming POM override dependencies

            // from the plugin's own POM.

            all.addAll( pluginDescriptor.getIntroducedDependencyArtifacts() );

            // add in the deps from the plugin POM now.

            all.addAll( rgArtifacts );

            for ( Iterator it = all.iterator(); it.hasNext(); )

            {

                Artifact artifact = (Artifact) it.next();

                String conflictId = artifact.getDependencyConflictId();

                // if the map already contains this dependencyConflictId, it constitutes an

                // overridden dependency. Don't use the old one (we know it's old from the

                // order in which dependencies were added to this list).

                if ( !dependencyMap.containsKey( conflictId ) )

                {

                    dependencyMap.put( conflictId, artifact );

                }

            }

            // Create an ordered set of dependencies from the ordered map we used above, to feed into the resolver.

            Set dependencies = new LinkedHashSet( dependencyMap.values() );

            if ( getLogger().isDebugEnabled() )

            {

                // list all dependencies to be used by this plugin (first-level deps, not transitive ones).

                getLogger().debug( "Plugin dependencies for:\n\n" + pluginDescriptor.getId()

                                   + "\n\nare:\n\n"

                                   + StringUtils.join( dependencies.iterator(), "\n" ) + "\n\n" );

            }

            List repositories = new ArrayList();

            repositories.addAll( resolutionGroup.getResolutionRepositories() );

            repositories.addAll( project.getRemoteArtifactRepositories() );

            /* get plugin managed versions */

            Map pluginManagedDependencies = new HashMap();

            try

            {

                MavenProject pluginProject =

                    mavenProjectBuilder.buildFromRepository( pluginArtifact, project.getRemoteArtifactRepositories(),

                                                             localRepository );

                if ( pluginProject != null )

                {

                    pluginManagedDependencies = pluginProject.getManagedVersionMap();

                }

            }

            catch ( ProjectBuildingException e )

            {

                // this can't happen, it would have blowed up at artifactMetadataSource.retrieve()

            }

            ArtifactResolutionResult result = artifactResolver.resolveTransitively( dependencies, pluginArtifact,

                                                                                    pluginManagedDependencies,

                                                                                    localRepository, repositories,

                                                                                    artifactMetadataSource,

                                                                                    artifactFilter );

            Set resolved = result.getArtifacts();

            for ( Iterator it = resolved.iterator(); it.hasNext(); )

            {

                Artifact artifact = (Artifact) it.next();

                if ( !artifact.equals( pluginArtifact ) )

                {

                    artifact = project.replaceWithActiveArtifact( artifact );

                    try

                    {

                        pluginContainer.addJarResource( artifact.getFile() );

                    }

                    catch ( PlexusContainerException e )

                    {

                        throw new PluginManagerException( "Error adding plugin dependency '" +

                            artifact.getDependencyConflictId() + "' into plugin manager: " + e.getMessage(), e );

                    }

                }

            }

            pluginDescriptor.setClassRealm( pluginContainer.getContainerRealm() );

            List unresolved = new ArrayList( dependencies );

            unresolved.removeAll( resolved );

            if ( getLogger().isDebugEnabled() )

            {

                // list all artifacts that were filtered out during the resolution process.

                // these are already present in the core container.

                getLogger().debug( " The following artifacts were filtered out for plugin: "

                                   + pluginDescriptor.getId()

                                   + " because they're already in the core of Maven:\n\n"

                                   + StringUtils.join( unresolved.iterator(), "\n" )

                                   + "\n\nThese will use the artifact files already in the core ClassRealm instead, to allow them to be included in PluginDescriptor.getArtifacts().\n\n" );

            }

            // Grab a file for all filtered artifacts, even if it means resolving them. This

            // is necessary in order to present a full complement of a plugin's transitive

            // dependencies to anyone who calls PluginDescriptor.getArtifacts().

            resolveCoreArtifacts( unresolved, localRepository, resolutionGroup.getResolutionRepositories() );

            // Re-join resolved and filtered-but-now-resolved artifacts.

            // NOTE: The process of filtering then re-adding some artifacts will

            // result in different ordering within the PluginDescriptor.getArtifacts()

            // List than should have happened if none had been filtered. All filtered

            // artifacts will be listed last...

            List allResolved = new ArrayList( resolved.size() + unresolved.size() );

            allResolved.addAll( resolved );

            allResolved.addAll( unresolved );

            pluginDescriptor.setArtifacts( allResolved );

        }

    }

    public static Set checkPlexusUtils( Set dependencyArtifacts, ArtifactFactory artifactFactory )

    {

        // ----------------------------------------------------------------------------

        // If the plugin already declares a dependency on plexus-utils then we're all

        // set as the plugin author is aware of its use. If we don't have a dependency

        // on plexus-utils then we must protect users from stupid plugin authors who

        // did not declare a direct dependency on plexus-utils because the version

        // Maven uses is hidden from downstream use. We will also bump up any

        // anything below 1.1 to 1.1 as this mimics the behaviour in 2.0.5 where

        // plexus-utils 1.1 was being forced into use.

        // ----------------------------------------------------------------------------

        VersionRange vr = null;

        try

        {

            vr = VersionRange.createFromVersionSpec( "[1.1,)" );

        }

        catch ( InvalidVersionSpecificationException e )

        {

            // Won't happen

        }

        boolean plexusUtilsPresent = false;

        for ( Iterator i = dependencyArtifacts.iterator(); i.hasNext(); )

        {

            Artifact a = (Artifact) i.next();

            if ( a.getArtifactId().equals( "plexus-utils" ) &&

                vr.containsVersion( new DefaultArtifactVersion( a.getVersion() ) ) )

            {

                plexusUtilsPresent = true;

                break;

            }

        }

        if ( !plexusUtilsPresent )

        {

            // We will add plexus-utils as every plugin was getting this anyway from Maven itself. We will set the

            // version to the latest version we know that works as of the 2.0.6 release. We set the scope to runtime

            // as this is what's implicitly happening in 2.0.6.

            Set result = new LinkedHashSet();

            if ( !dependencyArtifacts.isEmpty() )

            {

                result.addAll( dependencyArtifacts );

            }

            result.add( artifactFactory.createArtifact( "org.codehaus.plexus", "plexus-utils", "1.1", Artifact.SCOPE_RUNTIME, "jar" ) );

            return result;

        }

        else

        {

            return dependencyArtifacts;

        }

    }

    private void resolveCoreArtifacts( List unresolved,

                                       ArtifactRepository localRepository,

                                       List resolutionRepositories )

        throws ArtifactResolutionException, ArtifactNotFoundException

    {

        for ( Iterator it = unresolved.iterator(); it.hasNext(); )

        {

            Artifact artifact = (Artifact) it.next();

            File artifactFile = (File) resolvedCoreArtifactFiles.get( artifact.getId() );

            if ( artifactFile == null )

            {

                String resource =

                    "/META-INF/maven/" + artifact.getGroupId() + "/" + artifact.getArtifactId() + "/pom.xml";

                URL resourceUrl = container.getContainerRealm().getResource( resource );

                if ( resourceUrl == null )

                {

                    artifactResolver.resolve( artifact, resolutionRepositories, localRepository );

                    artifactFile = artifact.getFile();

                }

                else

                {

                    String artifactPath = resourceUrl.getPath();

                    if ( artifactPath.startsWith( "file:" ) )

                    {

                        artifactPath = artifactPath.substring( "file:".length() );

                    }

                    artifactPath = artifactPath.substring( 0, artifactPath.length() - resource.length() );

                    if ( artifactPath.endsWith( "/" ) )

                    {

                        artifactPath = artifactPath.substring( 0, artifactPath.length() - 1 );

                    }

                    if ( artifactPath.endsWith( "!" ) )

                    {

                        artifactPath = artifactPath.substring( 0, artifactPath.length() - 1 );

                    }

                    artifactFile = new File( artifactPath ).getAbsoluteFile();

                }

                resolvedCoreArtifactFiles.put( artifact.getId(), artifactFile );

            }

            artifact.setFile( artifactFile );

        }

    }

    private PlexusConfiguration extractMojoConfiguration( PlexusConfiguration mergedConfiguration,

                                                          MojoDescriptor mojoDescriptor )

    {

        Map parameterMap = mojoDescriptor.getParameterMap();

        PlexusConfiguration[] mergedChildren = mergedConfiguration.getChildren();

        XmlPlexusConfiguration extractedConfiguration = new XmlPlexusConfiguration( "configuration" );

        for ( int i = 0; i < mergedChildren.length; i++ )

        {

            PlexusConfiguration child = mergedChildren[i];

            if ( parameterMap.containsKey( child.getName() ) )

            {

                extractedConfiguration.addChild( copyConfiguration( child ) );

            }

            else

            {

                // TODO: I defy anyone to find these messages in the '-X' output! Do we need a new log level?

                // ideally, this would be elevated above the true debug output, but below the default INFO level...

                // [BP] (2004-07-18): need to understand the context more but would prefer this could be either WARN or

                // removed - shouldn't need DEBUG to diagnose a problem most of the time.

                getLogger().debug( "*** WARNING: Configuration \'" + child.getName() + "\' is not used in goal \'" +

                    mojoDescriptor.getFullGoalName() + "; this may indicate a typo... ***" );

            }

        }

        return extractedConfiguration;

    }

    private void checkRequiredParameters( MojoDescriptor goal,

                                          PlexusConfiguration configuration,

                                          ExpressionEvaluator expressionEvaluator )

        throws PluginConfigurationException

    {

        // TODO: this should be built in to the configurator, as we presently double process the expressions

        List parameters = goal.getParameters();

        if ( parameters == null )

        {

            return;

        }

        List invalidParameters = new ArrayList();

        for ( int i = 0; i < parameters.size(); i++ )

        {

            Parameter parameter = (Parameter) parameters.get( i );

            if ( parameter.isRequired() )

            {

                // the key for the configuration map we're building.

                String key = parameter.getName();

                Object fieldValue = null;

                String expression = null;

                PlexusConfiguration value = configuration.getChild( key, false );

                try

                {

                    if ( value != null )

                    {

                        expression = value.getValue( null );

                        fieldValue = expressionEvaluator.evaluate( expression );

                        if ( fieldValue == null )

                        {

                            fieldValue = value.getAttribute( "default-value", null );

                        }

                    }

                    if ( ( fieldValue == null ) && StringUtils.isNotEmpty( parameter.getAlias() ) )

                    {

                        value = configuration.getChild( parameter.getAlias(), false );

                        if ( value != null )

                        {

                            expression = value.getValue( null );

                            fieldValue = expressionEvaluator.evaluate( expression );

                            if ( fieldValue == null )

                            {

                                fieldValue = value.getAttribute( "default-value", null );

                            }

                        }

                    }

                }

                catch ( ExpressionEvaluationException e )

                {

                    throw new PluginConfigurationException( goal.getPluginDescriptor(), e.getMessage(), e );

                }

                // only mark as invalid if there are no child nodes

                if ( ( fieldValue == null ) && ( ( value == null ) || ( value.getChildCount() == 0 ) ) )

                {

                    parameter.setExpression( expression );

                    invalidParameters.add( parameter );

                }

            }

        }

        if ( !invalidParameters.isEmpty() )

        {

            throw new PluginParameterException( goal, invalidParameters );

        }

    }

    private void validatePomConfiguration( MojoDescriptor goal,

                                           PlexusConfiguration pomConfiguration )

        throws PluginConfigurationException

    {

        List parameters = goal.getParameters();

        if ( parameters == null )

        {

            return;

        }

        for ( int i = 0; i < parameters.size(); i++ )

        {

            Parameter parameter = (Parameter) parameters.get( i );

            // the key for the configuration map we're building.

            String key = parameter.getName();

            PlexusConfiguration value = pomConfiguration.getChild( key, false );

            if ( ( value == null ) && StringUtils.isNotEmpty( parameter.getAlias() ) )

            {

                key = parameter.getAlias();

                value = pomConfiguration.getChild( key, false );

            }

            if ( value != null )

            {

                // Make sure the parameter is either editable/configurable, or else is NOT specified in the POM

                if ( !parameter.isEditable() )

                {

                    StringBuffer errorMessage = new StringBuffer()

                        .append( "ERROR: Cannot override read-only parameter: " );

                    errorMessage.append( key );

                    errorMessage.append( " in goal: " ).append( goal.getFullGoalName() );

                    throw new PluginConfigurationException( goal.getPluginDescriptor(), errorMessage.toString() );

                }

                String deprecated = parameter.getDeprecated();

                if ( StringUtils.isNotEmpty( deprecated ) )

                {

                    getLogger().warn( "DEPRECATED [" + parameter.getName() + "]: " + deprecated );

                }

            }

        }

    }

    private PlexusConfiguration mergeMojoConfiguration( XmlPlexusConfiguration fromPom,

                                                        MojoDescriptor mojoDescriptor )

    {

        XmlPlexusConfiguration result = new XmlPlexusConfiguration( fromPom.getName() );

        result.setValue( fromPom.getValue( null ) );

        if ( mojoDescriptor.getParameters() != null )

        {

            PlexusConfiguration fromMojo = mojoDescriptor.getMojoConfiguration();

            for ( Iterator it = mojoDescriptor.getParameters().iterator(); it.hasNext(); )

            {

                Parameter parameter = (Parameter) it.next();

                String paramName = parameter.getName();

                String alias = parameter.getAlias();

                String implementation = parameter.getImplementation();

                PlexusConfiguration pomConfig = fromPom.getChild( paramName );

                PlexusConfiguration aliased = null;

                if ( alias != null )

                {

                    aliased = fromPom.getChild( alias );

                }

                PlexusConfiguration mojoConfig = fromMojo.getChild( paramName, false );

                // first we'll merge configurations from the aliased and real params.

                // TODO: Is this the right thing to do?

                if ( aliased != null )

                {

                    if ( pomConfig == null )

                    {

                        pomConfig = new XmlPlexusConfiguration( paramName );

                    }

                    pomConfig = buildTopDownMergedConfiguration( pomConfig, aliased );

                }

                PlexusConfiguration toAdd = null;

                if ( pomConfig != null )

                {

                    pomConfig = buildTopDownMergedConfiguration( pomConfig, mojoConfig );

                    if ( StringUtils.isNotEmpty( pomConfig.getValue( null ) ) || ( pomConfig.getChildCount() > 0 ) )

                    {

                        toAdd = pomConfig;

                    }

                }

                if ( ( toAdd == null ) && ( mojoConfig != null ) )

                {

                    toAdd = copyConfiguration( mojoConfig );

                }

                if ( toAdd != null )

                {

                    if ( ( implementation != null ) && ( toAdd.getAttribute( "implementation", null ) == null ) )

                    {

                        XmlPlexusConfiguration implementationConf = new XmlPlexusConfiguration( paramName );

                        implementationConf.setAttribute( "implementation", parameter.getImplementation() );

                        toAdd = buildTopDownMergedConfiguration( toAdd, implementationConf );

                    }

                    result.addChild( toAdd );

                }

            }

        }

        return result;

    }

    private XmlPlexusConfiguration buildTopDownMergedConfiguration( PlexusConfiguration dominant,

                                                                    PlexusConfiguration recessive )

    {

        XmlPlexusConfiguration result = new XmlPlexusConfiguration( dominant.getName() );

        String value = dominant.getValue( null );

        if ( StringUtils.isEmpty( value ) && ( recessive != null ) )

        {

            value = recessive.getValue( null );

        }

        if ( StringUtils.isNotEmpty( value ) )

        {

            result.setValue( value );

        }

        String[] attributeNames = dominant.getAttributeNames();

        for ( int i = 0; i < attributeNames.length; i++ )

        {

            String attributeValue = dominant.getAttribute( attributeNames[i], null );

            result.setAttribute( attributeNames[i], attributeValue );

        }

        if ( recessive != null )

        {

            attributeNames = recessive.getAttributeNames();

            for ( int i = 0; i < attributeNames.length; i++ )

            {

                String attributeValue = recessive.getAttribute( attributeNames[i], null );

                // TODO: recessive seems to be dominant here?

                result.setAttribute( attributeNames[i], attributeValue );

            }

        }

        PlexusConfiguration[] children = dominant.getChildren();

        for ( int i = 0; i < children.length; i++ )

        {

            PlexusConfiguration childDom = children[i];

            PlexusConfiguration childRec = recessive == null ? null : recessive.getChild( childDom.getName(), false );

            if ( childRec != null )

            {

                result.addChild( buildTopDownMergedConfiguration( childDom, childRec ) );

            }

            else

            {   // FIXME: copy, or use reference?

                result.addChild( copyConfiguration( childDom ) );

            }

        }

        return result;

    }

    public static PlexusConfiguration copyConfiguration( PlexusConfiguration src )

    {

        // TODO: shouldn't be necessary

        XmlPlexusConfiguration dom = new XmlPlexusConfiguration( src.getName() );

        dom.setValue( src.getValue( null ) );

        String[] attributeNames = src.getAttributeNames();

        for ( int i = 0; i < attributeNames.length; i++ )

        {

            String attributeName = attributeNames[i];

            dom.setAttribute( attributeName, src.getAttribute( attributeName, null ) );

        }

        PlexusConfiguration[] children = src.getChildren();

        for ( int i = 0; i < children.length; i++ )

        {

            dom.addChild( copyConfiguration( children[i] ) );

        }

        return dom;

    }

    // ----------------------------------------------------------------------

    // Mojo Parameter Handling

    // ----------------------------------------------------------------------

    private void populatePluginFields( Mojo plugin,

                                       MojoDescriptor mojoDescriptor,

                                       PlexusConfiguration configuration,

                                       PlexusContainer pluginContainer,

                                       ExpressionEvaluator expressionEvaluator )

        throws PluginConfigurationException

    {

        ComponentConfigurator configurator = null;

        try

        {

            String configuratorId = mojoDescriptor.getComponentConfigurator();

            // TODO: could the configuration be passed to lookup and the configurator known to plexus via the descriptor

            // so that this meethod could entirely be handled by a plexus lookup?

            if ( StringUtils.isNotEmpty( configuratorId ) )

            {

                configurator =

                    (ComponentConfigurator) pluginContainer.lookup( ComponentConfigurator.ROLE, configuratorId );

            }

            else

            {

                configurator = (ComponentConfigurator) pluginContainer.lookup( ComponentConfigurator.ROLE );

            }

            ConfigurationListener listener = new DebugConfigurationListener( getLogger() );

            getLogger().debug( "Configuring mojo '" + mojoDescriptor.getId() + "' -->" );

            configurator.configureComponent( plugin, configuration, expressionEvaluator,

                                             pluginContainer.getContainerRealm(), listener );

            getLogger().debug( "-- end configuration --" );

        }

        catch ( ComponentConfigurationException e )

        {

            throw new PluginConfigurationException( mojoDescriptor.getPluginDescriptor(),

                                                    "Unable to parse the created DOM for plugin configuration", e );

        }

        catch ( ComponentLookupException e )

        {

            throw new PluginConfigurationException( mojoDescriptor.getPluginDescriptor(),

                                                    "Unable to retrieve component configurator for plugin configuration",

                                                    e );

        }

        catch ( NoClassDefFoundError e )

        {

            throw new PluginConfigurationException( mojoDescriptor.getPluginDescriptor(),

                                                    "A required class was missing during mojo configuration: " + e.getMessage(), e );

        }

        catch ( LinkageError e )

        {

            if ( getLogger().isFatalErrorEnabled() )

            {

                getLogger().fatalError(

                                        configurator.getClass().getName() + "#configureComponent(...) caused a linkage error ("

                                            + e.getClass().getName() + ") and may be out-of-date. Check the realms:" );

                ClassRealm pluginRealm = mojoDescriptor.getPluginDescriptor().getClassRealm();

                StringBuffer sb = new StringBuffer();

                sb.append( "Plugin realm = " + pluginRealm.getId() ).append( '\n' );

                for ( int i = 0; i < pluginRealm.getConstituents().length; i++ )