201309.mbox/raw/%3c20130901111424.123052388CB2@eris.apache.org%3e

+
+    package org.apache.maven.plugin.resources.remote;
+
+    /*
+     * Licensed to the Apache Software Foundation (ASF) under one
+     * or more contributor license agreements.  See the NOTICE file
+     * distributed with this work for additional information
+     * regarding copyright ownership.  The ASF licenses this file
+     * to you under the Apache License, Version 2.0 (the
+     * "License"); you may not use this file except in compliance
+     * with the License.  You may obtain a copy of the License at
+     *
+     *   http://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing,
+     * software distributed under the License is distributed on an
+     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+     * KIND, either express or implied.  See the License for the
+     * specific language governing permissions and limitations
+     * under the License.
+     */
+
+    import org.apache.maven.ProjectDependenciesResolver;
+    import org.apache.maven.artifact.Artifact;
+    import org.apache.maven.artifact.factory.ArtifactFactory;
+    import org.apache.maven.artifact.repository.ArtifactRepository;
+    import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
+    import org.apache.maven.artifact.resolver.ArtifactResolutionException;
+    import org.apache.maven.artifact.resolver.ArtifactResolver;
+    import org.apache.maven.artifact.versioning.VersionRange;
+    import org.apache.maven.execution.MavenSession;
+    import org.apache.maven.model.Model;
+    import org.apache.maven.model.Organization;
+    import org.apache.maven.model.Resource;
+    import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
+    import org.apache.maven.plugin.AbstractMojo;
+    import org.apache.maven.plugin.MojoExecutionException;
+    import org.apache.maven.plugin.logging.Log;
+    import org.apache.maven.plugin.resources.remote.io.xpp3.RemoteResourcesBundleXpp3Reader;
+    import org.apache.maven.plugin.resources.remote.io.xpp3.SupplementalDataModelXpp3Reader;
+    import org.apache.maven.plugins.annotations.Component;
+    import org.apache.maven.plugins.annotations.LifecyclePhase;
+    import org.apache.maven.plugins.annotations.Mojo;
+    import org.apache.maven.plugins.annotations.Parameter;
+    import org.apache.maven.project.InvalidProjectModelException;
+    import org.apache.maven.project.MavenProject;
+    import org.apache.maven.project.MavenProjectBuilder;
+    import org.apache.maven.project.ProjectBuildingException;
+    import org.apache.maven.project.artifact.InvalidDependencyVersionException;
+    import org.apache.maven.project.inheritance.ModelInheritanceAssembler;
+    import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException;
+    import org.apache.maven.shared.artifact.filter.collection.ArtifactIdFilter;
+    import org.apache.maven.shared.artifact.filter.collection.FilterArtifacts;
+    import org.apache.maven.shared.artifact.filter.collection.GroupIdFilter;
+    import org.apache.maven.shared.artifact.filter.collection.ProjectTransitivityFilter;
+    import org.apache.maven.shared.artifact.filter.collection.ScopeFilter;
+    import org.apache.maven.shared.filtering.MavenFileFilter;
+    import org.apache.maven.shared.filtering.MavenFileFilterRequest;
+    import org.apache.maven.shared.filtering.MavenFilteringException;
+    import org.apache.velocity.VelocityContext;
+    import org.apache.velocity.app.Velocity;
+    import org.apache.velocity.app.VelocityEngine;
+    import org.apache.velocity.exception.MethodInvocationException;
+    import org.apache.velocity.exception.ParseErrorException;
+    import org.apache.velocity.exception.ResourceNotFoundException;
+    import org.apache.velocity.runtime.RuntimeServices;
+    import org.apache.velocity.runtime.log.LogChute;
+    import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader;
+    import org.codehaus.plexus.resource.ResourceManager;
+    import org.codehaus.plexus.resource.loader.FileResourceLoader;
+    import org.codehaus.plexus.util.FileUtils;
+    import org.codehaus.plexus.util.IOUtil;
+    import org.codehaus.plexus.util.ReaderFactory;
+    import org.codehaus.plexus.util.StringUtils;
+    import org.codehaus.plexus.util.WriterFactory;
+    import org.codehaus.plexus.util.xml.Xpp3Dom;
+    import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
+
+    import java.io.File;
+    import java.io.FileInputStream;
+    import java.io.FileOutputStream;
+    import java.io.FileReader;
+    import java.io.FileWriter;
+    import java.io.IOException;
+    import java.io.InputStream;
+    import java.io.InputStreamReader;
+    import java.io.OutputStream;
+    import java.io.OutputStreamWriter;
+    import java.io.PrintWriter;
+    import java.io.Reader;
+    import java.io.StringReader;
+    import java.io.Writer;
+    import java.net.MalformedURLException;
+    import java.net.URL;
+    import java.text.SimpleDateFormat;
+    import java.util.ArrayList;
+    import java.util.Arrays;
+    import java.util.Collections;
+    import java.util.Comparator;
+    import java.util.Date;
+    import java.util.Enumeration;
+    import java.util.HashMap;
+    import java.util.LinkedHashSet;
+    import java.util.List;
+    import java.util.Map;
+    import java.util.Properties;
+    import java.util.Set;
+    import java.util.TreeMap;
+
+    /**
+     * <p>
+     * Pull down resourceBundles containing remote resources and process the
+     * resources contained inside. When that is done the resources are injected
+     * into the current (in-memory) Maven project, making them available to the
+     * process-resources phase.
+     * </p>
+     * <p>
+     * Resources that end in ".vm" are treated as velocity templates.  For those, the ".vm" is
+     * stripped off for the final artifact name and it's  fed through velocity to have properties
+     * expanded, conditions processed, etc...
+     * </p>
+     * <p/>
+     * Resources that don't end in ".vm" are copied "as is".
+     */
+    // NOTE: Removed the following in favor of maven-artifact-resolver library, for MRRESOURCES-41
+    // If I leave this intact, interdependent projects within the reactor that haven't been built
+    // (remember, this runs in the generate-resources phase) will cause the build to fail.
+    //
+    // @requiresDependencyResolution test
+    @Mojo( name = "process", defaultPhase = LifecyclePhase.GENERATE_RESOURCES, threadSafe = true )
+    public class ProcessRemoteResourcesMojo
+        extends AbstractMojo implements LogChute
+    {
+
+        private static final String TEMPLATE_SUFFIX = ".vm";
+
+        /**
+         * <p>
+         * In cases where a local resource overrides one from a remote resource bundle, that resource
+         * should be filtered if the resource set specifies it. In those cases, this parameter defines
+         * the list of delimiters for filterable expressions. These delimiters are specified in the
+         * form 'beginToken*endToken'. If no '*' is given, the delimiter is assumed to be the same for start and end.
+         * </p>
+         * <p>
+         * So, the default filtering delimiters might be specified as:
+         * </p>
+         * <pre>
+         * &lt;delimiters&gt;
+         *   &lt;delimiter&gt;${*}&lt/delimiter&gt;
+         *   &lt;delimiter&gt;@&lt/delimiter&gt;
+         * &lt;/delimiters&gt;
+         * </pre>
+         * <p/>
+         * Since the '@' delimiter is the same on both ends, we don't need to specify '@*@' (though we can).
+         *
+         * @since 1.1
+         */
+        @Parameter
+        protected List<String> filterDelimiters;
+
+        /**
+         * @since 1.1
+         */
+        @Parameter( defaultValue = "true" )
+        protected boolean useDefaultFilterDelimiters;
+
+        /**
+         * If true, only generate resources in the directory of the root project in a multimodule build.
+         * Dependencies from all modules will be aggregated before resource-generation takes place.
+         *
+         * @since 1.1
+         */
+        @Parameter( defaultValue = "false" )
+        protected boolean runOnlyAtExecutionRoot;
+
+        /**
+         * Used for calculation of execution-root for {@link ProcessRemoteResourcesMojo#runOnlyAtExecutionRoot}.
+         */
+        @Parameter( defaultValue = "${basedir}", readonly = true, required = true )
+        protected File basedir;
+
+        /**
+         * The character encoding scheme to be applied when filtering resources.
+         */
+        @Parameter( property = "encoding", defaultValue = "${project.build.sourceEncoding}" )
+        protected String encoding;
+
+        /**
+         * The local repository taken from Maven's runtime. Typically $HOME/.m2/repository.
+         */
+        @Parameter( defaultValue = "${localRepository}", readonly = true, required = true )
+        private ArtifactRepository localRepository;
+
+        /**
+         * List of Remote Repositories used by the resolver.
+         */
+        @Parameter( defaultValue = "${project.remoteArtifactRepositories}", readonly = true, required = true )
+        private List<ArtifactRepository> remoteArtifactRepositories;
+
+        /**
+         * The current Maven project.
+         */
+        @Component
+        private MavenProject project;
+
+        /**
+         * The directory where processed resources will be placed for packaging.
+         */
+        @Parameter( defaultValue = "${project.build.directory}/maven-shared-archive-resources" )
+        private File outputDirectory;
+
+        /**
+         * The directory containing extra information appended to the generated resources.
+         */
+        @Parameter( defaultValue = "${basedir}/src/main/appended-resources" )
+        private File appendedResourcesDirectory;
+
+        /**
+         * Supplemental model data.  Useful when processing
+         * artifacts with incomplete POM metadata.
+         * <p/>
+         * By default, this Mojo looks for supplemental model
+         * data in the file "${appendedResourcesDirectory}/supplemental-models.xml".
+         *
+         * @since 1.0-alpha-5
+         */
+        @Parameter
+        private String[] supplementalModels;
+
+        /**
+         * List of artifacts that are added to the search path when looking
+         * for supplementalModels, expressed with
+         * <code>groupId:artifactId:version[:type[:classifier]]</code> format.
+         *
+         * @since 1.1
+         */
+        @Parameter
+        private List<String> supplementalModelArtifacts;
+
+        /**
+         * Map of artifacts to supplemental project object models.
+         */
+        private Map<String, Model> supplementModels;
+
+        /**
+         * Merges supplemental data model with artifact
+         * metadata.  Useful when processing artifacts with
+         * incomplete POM metadata.
+         */
+        @Component
+        private ModelInheritanceAssembler inheritanceAssembler;
+
+        /**
+         * The resource bundles that will be retrieved and processed,
+         * expressed with <code>groupId:artifactId:version[:type[:classifier]]</code> format.
+         */
+        @Parameter( required = true )
+        private List<String> resourceBundles;
+
+        /**
+         * Skip remote-resource processing
+         *
+         * @since 1.0-alpha-5
+         */
+        @Parameter( property = "remoteresources.skip", defaultValue = "false" )
+        private boolean skip;
+
+        /**
+         * Attaches the resources to the project as a resource directory.
+         *
+         * @since 1.0-beta-1
+         * @deprecated Please use {@link #attachToMain} and {@link #attachToTest} instead.
+         */
+        @Deprecated
+        @Parameter( defaultValue = "true" )
+        private boolean attached = true;
+
+        /**
+         * Attaches the resources to the main build of the project as a resource
+         * directory.
+         *
+         * @since 1.5
+         */
+        @Parameter( defaultValue = "true", property = "attachToMain" )
+        private boolean attachToMain;
+
+        /**
+         * Attaches the resources to the test build of the project as a resource
+         * directory.
+         *
+         * @since 1.5
+         */
+        @Parameter( defaultValue = "true", property = "attachToTest" )
+        private boolean attachToTest;
+
+        /**
+         * Additional properties to be passed to velocity.
+         * <p/>
+         * Several properties are automatically added:<br/>
+         * project - the current MavenProject <br/>
+         * projects - the list of dependency projects<br/>
+         * projectTimespan - the timespan of the current project (requires inceptionYear in pom)<br/>
+         * locator - the ResourceManager that can be used to retrieve additional resources<br/>
+         * <p/>
+         * See <a href="http://maven.apache.org/ref/current/maven-project/apidocs/org/apache/maven/project/MavenProject.html">
+         * the javadoc for MavenProject</a> for information about the properties on the MavenProject.
+         */
+        @Parameter
+        private Map<String, Object> properties = new HashMap<String, Object>();
+
+        /**
+         * Whether to include properties defined in the project when filtering resources.
+         *
+         * @since 1.2
+         */
+        @Parameter( defaultValue = "false" )
+        protected boolean includeProjectProperties = false;
+
+        /**
+         * The list of resources defined for the project.
+         */
+        @Parameter( defaultValue = "${project.resources}", readonly = true, required = true )
+        private List<Resource> resources;
+
+        /**
+         * Artifact Resolver, needed to resolve and download the {@code resourceBundles}.
+         */
+        @Component
+        private ArtifactResolver artifactResolver;
+
+        /**
+         * Filtering support, for local resources that override those in the remote bundle.
+         */
+        @Component
+        private MavenFileFilter fileFilter;
+
+        /**
+         * Artifact factory, needed to create artifacts.
+         */
+        @Component
+        private ArtifactFactory artifactFactory;
+
+        /**
+         * The Maven session.
+         */
+        @Component
+        private MavenSession mavenSession;
+
+        /**
+         * ProjectBuilder, needed to create projects from the artifacts.
+         */
+        @Component( role = MavenProjectBuilder.class )
+        private MavenProjectBuilder mavenProjectBuilder;
+
+        /**
+         */
+        @Component
+        private ResourceManager locator;
+
+
+        /**
+         * Scope to include. An Empty string indicates all scopes (default is "runtime").
+         *
+         * @since 1.0
+         */
+        @Parameter( property = "includeScope", defaultValue = "runtime" )
+        protected String includeScope;
+
+        /**
+         * Scope to exclude. An Empty string indicates no scopes (default).
+         *
+         * @since 1.0
+         */
+        @Parameter( property = "excludeScope", defaultValue = "" )
+        protected String excludeScope;
+
+
+        /**
+         * When resolving project dependencies, specify the scopes to include.
+         * The default is the same as "includeScope" if there are no exclude scopes set.
+         * Otherwise, it defaults to "test" to grab all the dependencies so the
+         * exclude filters can filter out what is not needed.
+         * @since 1.5
+         */
+        @Parameter
+        private String[] resolveScopes;
+
+
+        /**
+         * Comma separated list of Artifact names too exclude.
+         *
+         * @since 1.0
+         */
+        @Parameter( property = "excludeArtifactIds", defaultValue = "" )
+        protected String excludeArtifactIds;
+
+        /**
+         * Comma separated list of Artifact names to include.
+         *
+         * @since 1.0
+         */
+        @Parameter( property = "includeArtifactIds", defaultValue = "" )
+        protected String includeArtifactIds;
+
+        /**
+         * Comma separated list of GroupId Names to exclude.
+         *
+         * @since 1.0
+         */
+        @Parameter( property = "excludeGroupIds", defaultValue = "" )
+        protected String excludeGroupIds;
+
+        /**
+         * Comma separated list of GroupIds to include.
+         *
+         * @since 1.0
+         */
+        @Parameter( property = "includeGroupIds", defaultValue = "" )
+        protected String includeGroupIds;
+
+        /**
+         * If we should exclude transitive dependencies
+         *
+         * @since 1.0
+         */
+        @Parameter( property = "excludeTransitive", defaultValue = "false" )
+        protected boolean excludeTransitive;
+
+        /**
+         */
+        @Component( hint = "default" )
+        protected ProjectDependenciesResolver dependencyResolver;
+
+
+        private VelocityEngine velocity;
+
+        @SuppressWarnings( "unchecked" )
+        public void execute()
+            throws MojoExecutionException
+        {
+            if ( skip )
+            {
+                return;
+            }
+
+            if ( runOnlyAtExecutionRoot && !isExecutionRoot() )
+            {
+                getLog().info( "Skipping remote-resource generation in this project because it's not the Execution Root" );
+                return;
+            }
+            if ( resolveScopes == null )
+            {
+                if ( excludeScope == null || "".equals( excludeScope ) )
+                {
+                    resolveScopes = new String[] { this.includeScope };
+                }
+                else
+                {
+                    resolveScopes = new String[] { Artifact.SCOPE_TEST };
+                }
+            }
+            velocity = new VelocityEngine();
+            velocity.setProperty( VelocityEngine.RUNTIME_LOG_LOGSYSTEM, this );
+            velocity.setProperty( "resource.loader", "classpath" );
+            velocity.setProperty( "classpath.resource.loader.class", ClasspathResourceLoader.class.getName() );
+            velocity.init();
+
+            if ( supplementalModels == null )
+            {
+                File sups = new File( appendedResourcesDirectory, "supplemental-models.xml" );
+                if ( sups.exists() )
+                {
+                    try
+                    {
+                        supplementalModels = new String[]{ sups.toURI().toURL().toString() };
+                    }
+                    catch ( MalformedURLException e )
+                    {
+                        //ignore
+                        getLog().debug( "URL issue with supplemental-models.xml: " + e.toString() );
+                    }
+                }
+            }
+
+            addSupplementalModelArtifacts();
+            locator.addSearchPath( FileResourceLoader.ID, project.getFile().getParentFile().getAbsolutePath() );
+            if ( appendedResourcesDirectory != null )
+            {
+                locator.addSearchPath( FileResourceLoader.ID, appendedResourcesDirectory.getAbsolutePath() );
+            }
+            locator.addSearchPath( "url", "" );
+            locator.setOutputDirectory( new File( project.getBuild().getDirectory() ) );
+
+            if ( includeProjectProperties )
+            {
+                final Properties projectProperties = project.getProperties();
+                for ( Object key : projectProperties.keySet() )
+                {
+                    properties.put( key.toString(), projectProperties.get( key ).toString() );
+                }
+            }
+
+            ClassLoader origLoader = Thread.currentThread().getContextClassLoader();
+            try
+            {
+                Thread.currentThread().setContextClassLoader( this.getClass().getClassLoader() );
+
+                validate();
+
+                List<File> resourceBundleArtifacts = downloadBundles( resourceBundles );
+                supplementModels = loadSupplements( supplementalModels );
+
+                VelocityContext context = new VelocityContext( properties );
+                configureVelocityContext( context );
+
+                RemoteResourcesClassLoader classLoader = new RemoteResourcesClassLoader( null );
+
+                initalizeClassloader( classLoader, resourceBundleArtifacts );
+                Thread.currentThread().setContextClassLoader( classLoader );
+
+                processResourceBundles( classLoader, context );
+
+                try
+                {
+                    if ( outputDirectory.exists() )
+                    {
+                        // ----------------------------------------------------------------------------
+                        // Push our newly generated resources directory into the MavenProject so that
+                        // these resources can be picked up by the process-resources phase.
+                        // ----------------------------------------------------------------------------
+                        Resource resource = new Resource();
+                        resource.setDirectory( outputDirectory.getAbsolutePath() );
+                        // MRRESOURCES-61 handle main and test resources separately
+                        if ( attached && attachToMain )
+                        {
+                            project.getResources().add( resource );
+                        }
+                        if ( attached && attachToTest )
+                        {
+                            project.getTestResources().add( resource );
+                        }
+
+                        // ----------------------------------------------------------------------------
+                        // Write out archiver dot file
+                        // ----------------------------------------------------------------------------
+                        File dotFile = new File( project.getBuild().getDirectory(), ".plxarc" );
+                        FileUtils.mkdir( dotFile.getParentFile().getAbsolutePath() );
+                        FileUtils.fileWrite( dotFile.getAbsolutePath(), outputDirectory.getName() );
+                    }
+                }
+                catch ( IOException e )
+                {
+                    throw new MojoExecutionException( "Error creating dot file for archiving instructions.", e );
+                }
+            }
+            finally
+            {
+                Thread.currentThread().setContextClassLoader( origLoader );
+            }
+        }
+
+        private boolean isExecutionRoot()
+        {
+            Log log = this.getLog();
+
+            boolean result = mavenSession.getExecutionRootDirectory().equalsIgnoreCase( basedir.toString() );
+
+            if ( log.isDebugEnabled() )
+            {
+                log.debug( "Root Folder:" + mavenSession.getExecutionRootDirectory() );
+                log.debug( "Current Folder:" + basedir );
+
+                if ( result )
+                {
+                    log.debug( "This is the execution root." );
+                }
+                else
+                {
+                    log.debug( "This is NOT the execution root." );
+                }
+            }
+
+            return result;
+        }
+
+        private void addSupplementalModelArtifacts()
+            throws MojoExecutionException
+        {
+            if ( supplementalModelArtifacts != null && !supplementalModelArtifacts.isEmpty() )
+            {
+                List<File> artifacts = downloadBundles( supplementalModelArtifacts );
+
+                for ( File artifact : artifacts )
+                {
+                    if ( artifact.isDirectory() )
+                    {
+                        locator.addSearchPath( FileResourceLoader.ID, artifact.getAbsolutePath() );
+                    }
+                    else
+                    {
+                        try
+                        {
+                            locator.addSearchPath( "jar", "jar:" + artifact.toURI().toURL().toExternalForm() );
+                        }
+                        catch ( MalformedURLException e )
+                        {
+                            throw new MojoExecutionException( "Could not use jar " + artifact.getAbsolutePath(), e );
+                        }
+                    }
+                }
+
+
+            }
+        }
+
+        @SuppressWarnings( "unchecked" )
+        protected List<MavenProject> getProjects()
+            throws MojoExecutionException
+        {
+            List<MavenProject> projects = new ArrayList<MavenProject>();
+
+            // add filters in well known order, least specific to most specific
+            FilterArtifacts filter = new FilterArtifacts();
+
+            Set<Artifact> artifacts = resolveProjectArtifacts();
+            if ( this.excludeTransitive )
+            {
+                Set<Artifact> depArtifacts;
+                if ( runOnlyAtExecutionRoot )
+                {
+                    depArtifacts = aggregateProjectDependencyArtifacts();
+                }
+                else
+                {
+                    depArtifacts = project.getDependencyArtifacts();
+                }
+                filter.addFilter( new ProjectTransitivityFilter( depArtifacts, true ) );
+            }
+
+            filter.addFilter( new ScopeFilter( this.includeScope, this.excludeScope ) );
+            filter.addFilter( new GroupIdFilter( this.includeGroupIds, this.excludeGroupIds ) );
+            filter.addFilter( new ArtifactIdFilter( this.includeArtifactIds, this.excludeArtifactIds ) );
+
+            // perform filtering
+            try
+            {
+                artifacts = filter.filter( artifacts );
+            }
+            catch ( ArtifactFilterException e )
+            {
+                throw new MojoExecutionException( e.getMessage(), e );
+            }
+
+            for ( Artifact artifact : artifacts )
+            {
+                try
+                {
+                    List<ArtifactRepository> remoteRepo = remoteArtifactRepositories;
+                    if ( artifact.isSnapshot() )
+                    {
+                        VersionRange rng = VersionRange.createFromVersion( artifact.getBaseVersion() );
+                        artifact =
+                            artifactFactory.createDependencyArtifact( artifact.getGroupId(), artifact.getArtifactId(), rng,
+                                                                      artifact.getType(), artifact.getClassifier(),
+                                                                      artifact.getScope(), null, artifact.isOptional() );
+                    }
+
+                    getLog().debug( "Building project for " + artifact );
+                    MavenProject p = null;
+                    try
+                    {
+                        p = mavenProjectBuilder.buildFromRepository( artifact, remoteRepo, localRepository );
+                    }
+                    catch ( InvalidProjectModelException e )
+                    {
+                        getLog().warn( "Invalid project model for artifact [" + artifact.getArtifactId() + ":" +
+                                           artifact.getGroupId() + ":" + artifact.getVersion() + "]. " +
+                                           "It will be ignored by the remote resources Mojo." );
+                        continue;
+                    }
+
+                    String supplementKey =
+                        generateSupplementMapKey( p.getModel().getGroupId(), p.getModel().getArtifactId() );
+
+                    if ( supplementModels.containsKey( supplementKey ) )
+                    {
+                        Model mergedModel = mergeModels( p.getModel(), supplementModels.get( supplementKey ) );
+                        MavenProject mergedProject = new MavenProject( mergedModel );
+                        projects.add( mergedProject );
+                        mergedProject.setArtifact( artifact );
+                        mergedProject.setVersion( artifact.getVersion() );
+                        getLog().debug( "Adding project with groupId [" + mergedProject.getGroupId() + "] (supplemented)" );
+                    }
+                    else
+                    {
+                        projects.add( p );
+                        getLog().debug( "Adding project with groupId [" + p.getGroupId() + "]" );
+                    }
+                }
+                catch ( ProjectBuildingException e )
+                {
+                    throw new MojoExecutionException( e.getMessage(), e );
+                }
+            }
+            Collections.sort( projects, new ProjectComparator() );
+            return projects;
+        }
+
+        private Set<Artifact> resolveProjectArtifacts()
+            throws MojoExecutionException
+        {
+            try
+            {
+                if ( runOnlyAtExecutionRoot )
+                {

[... 773 lines stripped ...]