JasperReportsMojo.java

package org.codehaus.mojo.jasperreports;

/*
 * 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 java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.util.JRProperties;

import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.compiler.util.scan.InclusionScanException;
import org.codehaus.plexus.compiler.util.scan.SourceInclusionScanner;
import org.codehaus.plexus.compiler.util.scan.StaleSourceScanner;
import org.codehaus.plexus.compiler.util.scan.mapping.SourceMapping;
import org.codehaus.plexus.compiler.util.scan.mapping.SuffixMapping;

/**
 * Compiles JasperReports xml definition files.
 * <p>
 * Much of this was inspired by the JRAntCompileTask, while trying to make it slightly cleaner and
 * easier to use with Maven's mojo api.
 * </p>
 * 
 * @author gjoseph
 * @author Tom Schwenk
 * @goal compile-reports
 * @phase generate-sources
 * @requiresDependencyResolution compile
 */
public class JasperReportsMojo
    extends AbstractMojo
{
    /**
     * @parameter expression="${project}
     */
    private MavenProject project;

    /**
     * This is where the generated java sources are stored.
     * 
     * @parameter expression="${project.build.directory}/jasperreports/java"
     */
    private File javaDirectory;

    /**
     * This is where the .jasper files are written.
     * 
     * @parameter expression="${project.build.outputDirectory}"
     */
    private File outputDirectory;

    /**
     * This is where the xml report design files should be.
     * 
     * @parameter default-value="src/main/jasperreports"
     */
    private File sourceDirectory;

    /**
     * The extension of the source files to look for. Finds files with a .jrxml extension by
     * default.
     * 
     * @parameter default-value=".jrxml"
     */
    private String sourceFileExt;

    /**
     * The extension of the compiled report files. Creates files with a .jasper extension by
     * default.
     * 
     * @parameter default-value=".jasper"
     */
    private String outputFileExt;

    /**
     * Since the JasperReports compiler deletes the compiled classes, one might want to set this to
     * true, if they want to handle the generated java source in their application. Mind that this
     * will not work if the mojo is bound to the compile or any other later phase. (As one might
     * need to do if they use classes from their project in their report design)
     * 
     * @parameter default-value="false"
     * @deprecated There seems to be an issue with the compiler plugin so don't expect this to work
     *             yet - the dependencies will have disappeared.
     */
    private boolean keepJava;

    /**
     * Not used for now - just a TODO - the idea being that one might want to set this to false if
     * they want to handle the generated java source in their application.
     * 
     * @parameter default-value="true"
     * @deprecated Not implemented
     */
    private boolean keepSerializedObject;

    /**
     * Wether the xml design files must be validated.
     * 
     * @parameter default-value="true"
     */
    private boolean xmlValidation;

    /**
     * Uses the Javac compiler by default. This is different from the original JasperReports ant
     * task, which uses the JDT compiler by default.
     * 
     * @parameter default-value="net.sf.jasperreports.engine.design.JRJavacCompiler"
     */
    private String compiler;

    /**
     * @parameter expression="${project.compileClasspathElements}"
     */
    private List classpathElements;
    
    
    /**
     * Additional JRProperties
     * @parameter 
     * @since 1.0-beta-2
     */
    private Map additionalProperties = new HashMap();

    /**
     * Any additional classpath entry you might want to add to the JasperReports compiler. Not
     * recommended for general use, plugin dependencies should be used instead.
     * 
     * @parameter
     */
    private String additionalClasspath;

    public void execute()
        throws MojoExecutionException, MojoFailureException
    {
        getLog().debug( "javaDir = " + javaDirectory );
        getLog().debug( "sourceDirectory = " + sourceDirectory );
        getLog().debug( "sourceFileExt = " + sourceFileExt );
        getLog().debug( "targetDirectory = " + outputDirectory );
        getLog().debug( "targetFileExt = " + outputFileExt );
        getLog().debug( "keepJava = " + keepJava );
        //getLog().debug("keepSerializedObject = " + keepSerializedObject);
        getLog().debug( "xmlValidation = " + xmlValidation );
        getLog().debug( "compiler = " + compiler );
        getLog().debug( "classpathElements = " + classpathElements );
        getLog().debug( "additionalClasspath = " + additionalClasspath );

        checkDir( javaDirectory, "Directory for generated java sources", true );
        checkDir( sourceDirectory, "Source directory", false );
        checkDir( outputDirectory, "Target directory", true );

        SourceMapping mapping = new SuffixMapping( sourceFileExt, outputFileExt );

        Set staleSources = scanSrcDir( mapping );
        if ( staleSources.isEmpty() )
        {
            getLog().info( "Nothing to compile - all Jasper reports are up to date" );
        }
        else
        {
            // actual compilation
            compile( staleSources, mapping );

            if ( keepJava )
            {
                project.addCompileSourceRoot( javaDirectory.getAbsolutePath() );
            }
        }
    }

    protected void compile( Set files, SourceMapping mapping )
        throws MojoFailureException, MojoExecutionException
    {
        String classpath = buildClasspathString( classpathElements, additionalClasspath );
        getLog().debug( "buildClasspathString() = " + classpath );

        getLog().info( "Compiling " + files.size() + " report design files." );

        getLog().debug( "Set classloader" );
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Thread.currentThread().setContextClassLoader( getClassLoader( classLoader ) );

        JRProperties.backupProperties();

        try
        {
            JRProperties.setProperty( JRProperties.COMPILER_CLASSPATH, classpath );
            JRProperties.setProperty( JRProperties.COMPILER_TEMP_DIR, javaDirectory.getAbsolutePath() );
            JRProperties.setProperty( JRProperties.COMPILER_KEEP_JAVA_FILE, keepJava );
            JRProperties.setProperty( JRProperties.COMPILER_CLASS, compiler );
            JRProperties.setProperty( JRProperties.COMPILER_XML_VALIDATION, xmlValidation );

            for ( Iterator i = additionalProperties.keySet().iterator(); i.hasNext(); )
            {
                String key = (String) i.next();
                String value = (String) additionalProperties.get( key );
                JRProperties.setProperty( key, value );
                getLog().debug( "Added property: " + key + ":" + value );
            }
            
            Iterator it = files.iterator();
            while ( it.hasNext() )
            {
                File src = (File) it.next();
                String srcName = getPathRelativeToRoot( src );
                try
                {
                    // get the single destination file
                    File dest = (File) mapping.getTargetFiles( outputDirectory, srcName ).iterator().next();

                    File destFileParent = dest.getParentFile();
                    if ( !destFileParent.exists() )
                    {
                        if ( destFileParent.mkdirs() )
                        {
                            getLog().debug( "Created directory " + destFileParent );
                        }
                        else
                        {
                            throw new MojoExecutionException( "Could not create directory " + destFileParent );
                        }
                    }
                    getLog().info( "Compiling report file: " + srcName );
                    JasperCompileManager.compileReportToFile( src.getAbsolutePath(), dest.getAbsolutePath() );
                }
                catch ( JRException e )
                {
                    throw new MojoFailureException( this, "Error compiling report design : " + src,
                                                    "Error compiling report design : " + src + " : " + e.getMessage() );
                }
                catch ( InclusionScanException e )
                {
                    throw new MojoFailureException( this, "Error compiling report design : " + src,
                                                    "Error compiling report design : " + src + " : " + e.getMessage() );
                }
            }
        }
        finally
        {
            JRProperties.restoreProperties();

            if ( classLoader != null )
            {
                Thread.currentThread().setContextClassLoader( classLoader );
            }
        }
        getLog().info( "Compiled " + files.size() + " report design files." );
    }

    /**
     * Determines source files to be compiled, based on the SourceMapping. No longer needs to be
     * recursive, since the SourceInclusionScanner handles that.
     * 
     * @param mapping
     * @return
     * @throws MojoExecutionException
     */
    protected Set scanSrcDir( SourceMapping mapping )
        throws MojoExecutionException
    {
        final int staleMillis = 0;

        SourceInclusionScanner scanner = new StaleSourceScanner( staleMillis );
        scanner.addSourceMapping( mapping );

        try
        {
            return scanner.getIncludedSources( sourceDirectory, outputDirectory );
        }
        catch ( InclusionScanException e )
        {
            throw new MojoExecutionException( "Error scanning source root: \'" + sourceDirectory + "\' "
                + "for stale files to recompile.", e );
        }
    }

    private String getPathRelativeToRoot( File file )
        throws MojoExecutionException
    {
        try
        {
            String root = this.sourceDirectory.getCanonicalPath();
            String filePath = file.getCanonicalPath();
            if ( !filePath.startsWith( root ) )
            {
                throw new MojoExecutionException( "File is not in source root ??? " + file );
            }
            return filePath.substring( root.length() + 1 );
        }
        catch ( IOException e )
        {
            throw new MojoExecutionException( "Could not getCanonicalPath from file " + file, e );
        }
    }

    protected String buildClasspathString( List classpathElements, String additionalClasspath )
    {
        StringBuffer classpath = new StringBuffer();
        Iterator it = classpathElements.iterator();
        while ( it.hasNext() )
        {
            String cpElement = (String) it.next();
            classpath.append( cpElement );
            if ( it.hasNext() )
            {
                classpath.append( File.pathSeparator );
            }
        }
        if ( additionalClasspath != null )
        {
            if ( classpath.length() > 0 )
            {
                classpath.append( File.pathSeparator );
            }
            classpath.append( additionalClasspath );

        }
        return classpath.toString();
    }

    private void checkDir( File dir, String desc, boolean isTarget )
        throws MojoExecutionException
    {
        if ( dir.exists() && !dir.isDirectory() )
        {
            throw new MojoExecutionException( desc + " is not a directory : " + dir );
        }
        else if ( !dir.exists() && isTarget && !dir.mkdirs() )
        {
            throw new MojoExecutionException( desc + " could not be created : " + dir );
        }

        if ( isTarget && !dir.canWrite() )
        {
            throw new MojoExecutionException( desc + " is not writable : " + dir );
        }
    }

    private ClassLoader getClassLoader( ClassLoader classLoader )
        throws MojoExecutionException
    {
        List classpathURLs = new ArrayList();

        for ( int i = 0; i < classpathElements.size(); i++ )
        {
            String element = (String) classpathElements.get( i );
            try
            {
                File f = new File( element );
                URL newURL = f.toURI().toURL();
                classpathURLs.add( newURL );
                getLog().debug( "Added to classpath " + element );
            }
            catch ( Exception e )
            {
                throw new MojoExecutionException( "Error parsing classparh " + element + " " + e.getMessage() );
            }
        }

        if ( additionalClasspath != null && additionalClasspath.length() > 0 )
        {
            String[] elements = additionalClasspath.split( File.pathSeparator );
            for ( int i = 0; i < elements.length; i++ )
            {
                String element = elements[i];
                try
                {
                    File f = new File( element );
                    URL newURL = f.toURI().toURL();
                    classpathURLs.add( newURL );
                    getLog().debug( "Added to classpath " + element );
                }
                catch ( Exception e )
                {
                    throw new MojoExecutionException( "Error parsing classpath " + additionalClasspath + " "
                        + e.getMessage() );
                }
            }
        }

        URL[] urls = (URL[]) classpathURLs.toArray( new URL[classpathURLs.size()] );
        return new URLClassLoader( urls, classLoader );
    }

}