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.ScopeFilter;

 import org.apache.maven.shared.artifact.filter.collection.TransitivityFilter;

 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.exception.MethodInvocationException;

 import org.apache.velocity.exception.ParseErrorException;

 import org.apache.velocity.exception.ResourceNotFoundException;

 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 org.codehaus.plexus.velocity.VelocityComponent;

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

 {

     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>

      * <delimiters>

      *   <delimiter>${*}&lt/delimiter>

      *   <delimiter>@&lt/delimiter>

      * </delimiters>

      * </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 resource to the project as a resource directory

      *

      * @since 1.0-beta-1

      */

     @Parameter( defaultValue = "true" )

     private boolean attached = true;

     /**

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

      * <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, String> properties = new HashMap<String, String>();

     /**

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

     /**

      * Velocity component.

      */

     @Component

     private VelocityComponent velocity;

     /**

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

      *

      * @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;

     /**

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

     @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 ( supplementalModels == null )

         {

             File sups = new File( appendedResourcesDirectory, "supplemental-models.xml" );

             if ( sups.exists() )

             {

                 try

                 {

                     supplementalModels = new String[]{ sups.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.

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

                     if ( attached )

                     {

                         Resource resource = new Resource();

                         resource.setDirectory( outputDirectory.getAbsolutePath() );

                         project.getResources().add( resource );

                         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.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> depArtifacts;

         Set<Artifact> artifacts = resolveProjectArtifacts();

         if ( runOnlyAtExecutionRoot )

         {

             depArtifacts = aggregateProjectDependencyArtifacts();

         }

         else

         {

             depArtifacts = project.getDependencyArtifacts();

         }

         filter.addFilter( new TransitivityFilter( depArtifacts, this.excludeTransitive ) );

         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(), (Model) 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;

     }

     @SuppressWarnings( "unchecked" )

     private Set<Artifact> resolveProjectArtifacts()

         throws MojoExecutionException

     {

         try

         {

             if ( runOnlyAtExecutionRoot )

             {

                 List<MavenProject> projects = mavenSession.getSortedProjects();

                 return dependencyResolver.resolve( projects, Collections.singleton( Artifact.SCOPE_TEST ),

                                                    mavenSession );

             }

             else

             {

                 return dependencyResolver.resolve( project, Collections.singleton( Artifact.SCOPE_TEST ),

                                                    mavenSession );

             }

         }

         catch ( ArtifactResolutionException e )

         {

             throw new MojoExecutionException(

                 "Failed to resolve dependencies for one or more projects in the reactor. Reason: " + e.getMessage(),

                 e );

         }

         catch ( ArtifactNotFoundException e )

         {

             throw new MojoExecutionException(

                 "Failed to resolve dependencies for one or more projects in the reactor. Reason: " + e.getMessage(),

                 e );

         }

     }

     @SuppressWarnings( "unchecked" )

     private Set<Artifact> aggregateProjectDependencyArtifacts()

         throws MojoExecutionException

     {

         Set<Artifact> artifacts = new LinkedHashSet<Artifact>();

         List<MavenProject> projects = mavenSession.getSortedProjects();

         for ( MavenProject p : projects )

         {

             if ( p.getDependencyArtifacts() == null )

             {

                 try

                 {

                     Set<Artifact> depArtifacts = p.createArtifacts( artifactFactory, null, null );

                     p.setDependencyArtifacts( depArtifacts );

                     if ( depArtifacts != null && !depArtifacts.isEmpty() )

                     {

                         artifacts.addAll( depArtifacts );

                     }

                 }

                 catch ( InvalidDependencyVersionException e )

                 {

                     throw new MojoExecutionException(

                         "Failed to create dependency artifacts for: " + p.getId() + ". Reason: " + e.getMessage(), e );

                 }

             }

         }

         return artifacts;

     }

     protected Map<Organization, List<MavenProject>> getProjectsSortedByOrganization( List<MavenProject> projects )

         throws MojoExecutionException

     {

         Map<Organization, List<MavenProject>> organizations =

             new TreeMap<Organization, List<MavenProject>>( new OrganizationComparator() );

         List<MavenProject> unknownOrganization = new ArrayList<MavenProject>();

         for ( MavenProject p : projects )

         {

             if ( p.getOrganization() != null && StringUtils.isNotEmpty( p.getOrganization().getName() ) )

             {

                 List<MavenProject> sortedProjects = (List<MavenProject>) organizations.get( p.getOrganization() );

                 if ( sortedProjects == null )

                 {

                     sortedProjects = new ArrayList<MavenProject>();

                 }

                 sortedProjects.add( p );

                 organizations.put( p.getOrganization(), sortedProjects );

             }

             else

             {

                 unknownOrganization.add( p );

             }

         }

         if ( !unknownOrganization.isEmpty() )

         {

             Organization unknownOrg = new Organization();

             unknownOrg.setName( "an unknown organization" );

             organizations.put( unknownOrg, unknownOrganization );

         }

         return organizations;

     }

     protected boolean copyResourceIfExists( File file, String relFileName, VelocityContext context )

         throws IOException, MojoExecutionException

     {

         for ( Resource resource : resources )

         {

             File resourceDirectory = new File( resource.getDirectory() );

             if ( !resourceDirectory.exists() )

             {

                 continue;

             }

             //TODO - really should use the resource includes/excludes and name mapping

             File source = new File( resourceDirectory, relFileName );

             File templateSource = new File( resourceDirectory, relFileName + TEMPLATE_SUFFIX );

             if ( !source.exists() && templateSource.exists() )

             {

                 source = templateSource;

             }

             if ( source.exists() && !source.equals( file ) )

             {

                 if ( source == templateSource )

                 {

                     Reader reader = null;

                     Writer writer = null;

                     try

                     {

                         if ( encoding != null )

                         {

                             reader = new InputStreamReader( new FileInputStream( source ), encoding );

                             writer = new OutputStreamWriter( new FileOutputStream( file ), encoding );

                         }

                         else

                         {

                             reader = ReaderFactory.newPlatformReader( source );

                             writer = WriterFactory.newPlatformWriter( file );

                         }

                         velocity.getEngine().evaluate( context, writer, "", reader );

                         velocity.getEngine().evaluate( context, writer, "", reader );

                     }

                     catch ( ParseErrorException e )

                     {

                         throw new MojoExecutionException( "Error rendering velocity resource.", e );

                     }

                     catch ( MethodInvocationException e )

                     {

                         throw new MojoExecutionException( "Error rendering velocity resource.", e );

                     }

                     catch ( ResourceNotFoundException e )

                     {

                         throw new MojoExecutionException( "Error rendering velocity resource.", e );

                     }

                     finally

                     {

                         IOUtil.close( writer );

                         IOUtil.close( reader );

                     }

                 }

                 else if ( resource.isFiltering() )

                 {

                     MavenFileFilterRequest req = setupRequest( resource, source, file );

                     try

                     {

                         fileFilter.copyFile( req );

                     }

                     catch ( MavenFilteringException e )

                     {

                         throw new MojoExecutionException( "Error filtering resource: " + source, e );

                     }

                 }

                 else

                 {

                     FileUtils.copyFile( source, file );

                 }

                 //exclude the original (so eclipse doesn't complain about duplicate resources)

                 resource.addExclude( relFileName );

                 return true;

             }

         }

         return false;

     }

     @SuppressWarnings( "unchecked" )

     private MavenFileFilterRequest setupRequest( Resource resource, File source, File file )

     {

         MavenFileFilterRequest req = new MavenFileFilterRequest();

         req.setFrom( source );

         req.setTo( file );

         req.setFiltering( resource.isFiltering() );

         req.setMavenProject( project );

         req.setMavenSession( mavenSession );

         req.setInjectProjectBuildFilters( true );

         if ( encoding != null )

         {

             req.setEncoding( encoding );

         }

         if ( filterDelimiters != null && !filterDelimiters.isEmpty() )

         {

             LinkedHashSet<String> delims = new LinkedHashSet<String>();

             if ( useDefaultFilterDelimiters )

             {

                 delims.addAll( req.getDelimiters() );

             }

             for ( String delim : filterDelimiters )

             {

                 if ( delim == null )

                 {

                     delims.add( "${*}" );

                 }

                 else

                 {

                     delims.add( delim );

                 }

             }

             req.setDelimiters( delims );

         }

         return req;

     }

     protected void validate()

         throws MojoExecutionException

     {

         int bundleCount = 1;

         for ( String artifactDescriptor : resourceBundles )

         {

             // groupId:artifactId:version, groupId:artifactId:version:type

             // or groupId:artifactId:version:type:classifier

             String[] s = StringUtils.split( artifactDescriptor, ":" );

             if ( s.length < 3 || s.length > 5 )

             {

                 String position;

                 if ( bundleCount == 1 )

                 {

                     position = "1st";

                 }

                 else if ( bundleCount == 2 )

                 {

                     position = "2nd";

                 }

                 else if ( bundleCount == 3 )

                 {

                     position = "3rd";

                 }

                 else

                 {

                     position = bundleCount + "th";

                 }

                 throw new MojoExecutionException( "The " + position +

                                                       " resource bundle configured must specify a groupId, artifactId, " +

                                                       " version and, optionally, type and classifier for a remote resource bundle. " +

                                                       "Must be of the form <resourceBundle>groupId:artifactId:version</resourceBundle>, " +

                                                       "<resourceBundle>groupId:artifactId:version:type</resourceBundle> or " +

                                                       "<resourceBundle>groupId:artifactId:version:type:classifier</resourceBundle>" );

             }

             bundleCount++;

         }

     }

     protected void configureVelocityContext( VelocityContext context )

         throws MojoExecutionException

     {

         String inceptionYear = project.getInceptionYear();

         String year = new SimpleDateFormat( "yyyy" ).format( new Date() );

         if ( StringUtils.isEmpty( inceptionYear ) )

         {

             if ( getLog().isDebugEnabled() )

             {

                 getLog().debug( "inceptionYear not specified, defaulting to " + year );

             }

             inceptionYear = year;

         }

         context.put( "project", project );

         List<MavenProject> projects = getProjects();

         context.put( "projects", projects );

         context.put( "projectsSortedByOrganization", getProjectsSortedByOrganization( projects ) );

         context.put( "presentYear", year );

         if ( inceptionYear.equals( year ) )

         {

             context.put( "projectTimespan", year );

         }

         else

         {

             context.put( "projectTimespan", inceptionYear + "-" + year );

         }

     }

     @SuppressWarnings( "unchecked" )

     private List<File> downloadBundles( List<String> bundles )

         throws MojoExecutionException

     {

         List<File> bundleArtifacts = new ArrayList<File>();

         try

         {

             for ( String artifactDescriptor : bundles )

             {

                 // groupId:artifactId:version[:type[:classifier]]

                 String[] s = artifactDescriptor.split( ":" );

                 File artifactFile = null;

                 //check if the artifact is part of the reactor

                 if ( mavenSession != null )

                 {

                     List<MavenProject> list = mavenSession.getSortedProjects();

                     for ( MavenProject p : list )

                     {

                         if ( s[0].equals( p.getGroupId() ) && s[1].equals( p.getArtifactId() ) &&

                             s[2].equals( p.getVersion() ) )

                         {

                             artifactFile = new File( p.getBuild().getOutputDirectory() );

                         }

                     }

                 }

                 if ( artifactFile == null || !artifactFile.exists() )

                 {

                     String type = ( s.length >= 4 ? s[3] : "jar" );

                     String classifier = ( s.length == 5 ? s[4] : null );

                     Artifact artifact =

                         artifactFactory.createDependencyArtifact( s[0], s[1], VersionRange.createFromVersion( s[2] ),

                                                                   type, classifier, Artifact.SCOPE_RUNTIME );

                     artifactResolver.resolve( artifact, remoteArtifactRepositories, localRepository );

                     artifactFile = artifact.getFile();

                 }

                 bundleArtifacts.add( artifactFile );

             }

         }

         catch ( ArtifactResolutionException e )

         {

             throw new MojoExecutionException( "Error downloading resources archive.", e );

         }

         catch ( ArtifactNotFoundException e )

         {

             throw new MojoExecutionException( "Resources archive cannot be found.", e );

         }

         return bundleArtifacts;

     }

     private void initalizeClassloader( RemoteResourcesClassLoader cl, List<File> artifacts )

         throws MojoExecutionException

     {

         try

         {

             for ( File artifact : artifacts )

             {

                 cl.addURL( artifact.toURI().toURL() );

             }

         }

         catch ( MalformedURLException e )

         {

             throw new MojoExecutionException( "Unable to configure resources classloader: " + e.getMessage(), e );

         }

     }

     protected void processResourceBundles( RemoteResourcesClassLoader classLoader, VelocityContext context )

         throws MojoExecutionException

     {

         InputStreamReader reader = null;

         try

         {

             for ( Enumeration<URL> e = classLoader.getResources( BundleRemoteResourcesMojo.RESOURCES_MANIFEST );

                   e.hasMoreElements(); )

             {

                 URL url = (URL) e.nextElement();

                 try

                 {

                     reader = new InputStreamReader( url.openStream() );

                     RemoteResourcesBundleXpp3Reader bundleReader = new RemoteResourcesBundleXpp3Reader();

                     RemoteResourcesBundle bundle = bundleReader.read( reader );

                     for ( String bundleResource : (List<String>) bundle.getRemoteResources() )

                     {

                         String projectResource = bundleResource;

                         boolean doVelocity = false;

                         if ( projectResource.endsWith( TEMPLATE_SUFFIX ) )

                         {

                             projectResource = projectResource.substring( 0, projectResource.length() - 3 );

                             doVelocity = true;

                         }

                         // Don't overwrite resource that are already being provided.

                         File f = new File( outputDirectory, projectResource );

                         FileUtils.mkdir( f.getParentFile().getAbsolutePath() );

                         if ( !copyResourceIfExists( f, projectResource, context ) )

                         {

                             if ( doVelocity )

                             {

                                 PrintWriter writer;

                                 if ( bundle.getSourceEncoding() == null )

                                 {

                                     writer = new PrintWriter( new FileWriter( f ) );

                                 }

                                 else

                                 {

                                     writer = new PrintWriter( new OutputStreamWriter( new FileOutputStream( f ),

                                                                                       bundle.getSourceEncoding() ) );

                                 }

                                 try

                                 {

                                     if ( bundle.getSourceEncoding() == null )

                                     {

                                         velocity.getEngine().mergeTemplate( bundleResource, context, writer );

                                     }

                                     else

                                     {

                                         velocity.getEngine().mergeTemplate( bundleResource, bundle.getSourceEncoding(),

                                                                             context, writer );

                                     }

                                 }

                                 finally

                                 {

                                     IOUtil.close( writer );

                                 }

                             }

                             else

                             {

                                 URL resUrl = classLoader.getResource( bundleResource );

                                 if ( resUrl != null )

                                 {

                                     FileUtils.copyURLToFile( resUrl, f );

                                 }

                             }

                             File appendedResourceFile = new File( appendedResourcesDirectory, projectResource );

                             File appendedVmResourceFile =

                                 new File( appendedResourcesDirectory, projectResource + ".vm" );

                             if ( appendedResourceFile.exists() )

                             {

                                 final InputStream in = new FileInputStream( appendedResourceFile );

                                 final OutputStream append = new FileOutputStream( f, true );

                                 try

                                 {

                                     IOUtil.copy( in, append );

                                 }

                                 finally

                                 {

                                     IOUtil.close( in );

                                     IOUtil.close( append );

                                 }

                             }

                             else if ( appendedVmResourceFile.exists() )

                             {

                                 PrintWriter writer;

                                 FileReader freader = new FileReader( appendedVmResourceFile );

                                 if ( bundle.getSourceEncoding() == null )

                                 {

                                     writer = new PrintWriter( new FileWriter( f, true ) );

                                 }

                                 else

                                 {

                                     writer = new PrintWriter( new OutputStreamWriter( new FileOutputStream( f, true ),

                                                                                       bundle.getSourceEncoding() ) );

                                 }

                                 try

                                 {

                                     Velocity.init();

                                     Velocity.evaluate( context, writer, "remote-resources", freader );

                                 }

                                 finally

                                 {

                                     IOUtil.close( writer );

                                     IOUtil.close( freader );

                                 }

                             }

                         }

                     }

                 }

                 finally

                 {

                     reader.close();

                 }

             }

         }

         catch ( IOException e )

         {

             throw new MojoExecutionException( "Error finding remote resources manifests", e );

         }

         catch ( XmlPullParserException e )

         {

             throw new MojoExecutionException( "Error parsing remote resource bundle descriptor.", e );

         }

         catch ( Exception e )

         {

             throw new MojoExecutionException( "Error rendering velocity resource.", e );

         }

     }

     protected Model getSupplement( Xpp3Dom supplementModelXml )

         throws MojoExecutionException

     {

         MavenXpp3Reader modelReader = new MavenXpp3Reader();

         Model model = null;

         try

         {

             model = modelReader.read( new StringReader( supplementModelXml.toString() ) );

             String groupId = model.getGroupId();

             String artifactId = model.getArtifactId();

             if ( groupId == null || groupId.trim().equals( "" ) )

             {

                 throw new MojoExecutionException(

                     "Supplemental project XML " + "requires that a <groupId> element be present." );

             }

             if ( artifactId == null || artifactId.trim().equals( "" ) )

             {

                 throw new MojoExecutionException(

                     "Supplemental project XML " + "requires that a <artifactId> element be present." );

             }

         }

         catch ( IOException e )

         {

             getLog().warn( "Unable to read supplemental XML: " + e.getMessage(), e );

         }

         catch ( XmlPullParserException e )

         {

             getLog().warn( "Unable to parse supplemental XML: " + e.getMessage(), e );

         }

         return model;

     }

     protected Model mergeModels( Model parent, Model child )

     {

         inheritanceAssembler.assembleModelInheritance( child, parent );

         return child;

     }

     private static String generateSupplementMapKey( String groupId, String artifactId )

     {

         return groupId.trim() + ":" + artifactId.trim();

     }

     private Map<String, Model> loadSupplements( String models[] )

         throws MojoExecutionException

     {

         if ( models == null )

         {

             getLog().debug( "Supplemental data models won't be loaded.  " + "No models specified." );

             return Collections.emptyMap();

         }

         List<Supplement> supplements = new ArrayList<Supplement>();

         for ( int idx = 0; idx < models.length; idx++ )

         {

             String set = models[idx];

             getLog().debug( "Preparing ruleset: " + set );

             try

             {

                 File f = locator.getResourceAsFile( set, getLocationTemp( set ) );

                 if ( null == f || !f.exists() )

                 {

                     throw new MojoExecutionException( "Cold not resolve " + set );

                 }

                 if ( !f.canRead() )

                 {

                     throw new MojoExecutionException( "Supplemental data models won't be loaded. " + "File " +

                                                           f.getAbsolutePath() +

                                                           " cannot be read, check permissions on the file." );

                 }

                 getLog().debug( "Loading supplemental models from " + f.getAbsolutePath() );

                 SupplementalDataModelXpp3Reader reader = new SupplementalDataModelXpp3Reader();

                 SupplementalDataModel supplementalModel = reader.read( new FileReader( f ) );

                 supplements.addAll( supplementalModel.getSupplement() );

             }

             catch ( Exception e )

             {

                 String msg = "Error loading supplemental data models: " + e.getMessage();

                 getLog().error( msg, e );

                 throw new MojoExecutionException( msg, e );

             }

         }

         getLog().debug( "Loading supplements complete." );

         Map<String, Model> supplementMap = new HashMap<String, Model>();

         for ( Supplement sd : supplements )

         {

             Xpp3Dom dom = (Xpp3Dom) sd.getProject();

             Model m = getSupplement( dom );

             supplementMap.put( generateSupplementMapKey( m.getGroupId(), m.getArtifactId() ), m );

         }

         return supplementMap;

     }

     /**

      * Convenience method to get the location of the specified file name.

      *

      * @param name the name of the file whose location is to be resolved

      * @return a String that contains the absolute file name of the file

      */

     private String getLocationTemp( String name )

     {

         String loc = name;

         if ( loc.indexOf( '/' ) != -1 )

         {

             loc = loc.substring( loc.lastIndexOf( '/' ) + 1 );

         }

         if ( loc.indexOf( '\\' ) != -1 )

         {

             loc = loc.substring( loc.lastIndexOf( '\\' ) + 1 );

         }

         getLog().debug( "Before: " + name + " After: " + loc );

         return loc;

     }

     class OrganizationComparator

         implements Comparator<Organization>

     {

         public int compare( Organization org1, Organization org2 )

         {

             int i = compareStrings( org1.getName(), org2.getName() );

             if ( i == 0 )

             {

                 i = compareStrings( org1.getUrl(), org2.getUrl() );

             }

             return i;

         }

         public boolean equals( Organization o1, Organization o2 )

         {

             return compare( o1, o2 ) == 0;

         }

         private int compareStrings( String s1, String s2 )

         {

             if ( s1 == null && s2 == null )