FileDocCategorySizeDatePackage
AggregateTransformer.javaAPI DocApache Ant 1.7011583Wed Dec 13 06:16:20 GMT 2006org.apache.tools.ant.taskdefs.optional.junit

AggregateTransformer

public class AggregateTransformer extends Object
Transform a JUnit xml report. The default transformation generates an html report in either framed or non-framed style. The non-framed style is convenient to have a concise report via mail, the framed report is much more convenient if you want to browse into different packages or testcases since it is a Javadoc like report.

Fields Summary
public static final String
FRAMES
name of the frames format.
public static final String
NOFRAMES
name of the no frames format.
protected org.apache.tools.ant.Task
task
Task
protected Document
document
the xml document to process
protected File
styleDir
the style directory. XSLs should be read from here if necessary
protected File
toDir
the destination directory, this is the root from where html should be generated
private List
params
The params that will be sent to the XSL transformation
private static final org.apache.tools.ant.util.FileUtils
FILE_UTILS
Instance of a utility class to use for file operations.
private static int
counter
Used to ensure the uniqueness of a property
protected String
format
the format to use for the report. Must be FRAMES or NOFRAMES
private static DocumentBuilderFactory
privateDBFactory
XML Parser factory
protected static DocumentBuilderFactory
dbfactory
XML Parser factory accessible to subclasses
Constructors Summary
public AggregateTransformer(org.apache.tools.ant.Task task)
constructor creating the transformer from the junitreport task.

param
task task delegating to this class


     
       privateDBFactory = DocumentBuilderFactory.newInstance();
       dbfactory = privateDBFactory;
    
        this.task = task;
        params = new Vector();
    
Methods Summary
protected voidcheckOptions()
check for invalid options

throws
BuildException if something goes wrong.

        // set the destination directory relative from the project if needed.
        if (toDir == null) {
            toDir = task.getProject().resolveFile(".");
        } else if (!toDir.isAbsolute()) {
            toDir = task.getProject().resolveFile(toDir.getPath());
        }
    
public XSLTProcess.ParamcreateParam()
Create an instance of an XSL parameter for configuration by Ant.

return
an instance of the Param class to be configured.
since
Ant 1.7

        XSLTProcess.Param p = new XSLTProcess.Param();
        params.add(p);
        return p;
    
protected static javax.xml.parsers.DocumentBuilderFactorygetDocumentBuilderFactory()
Get the Document Builder Factory

return
the DocumentBuilderFactory instance in use

        return privateDBFactory;
    
protected org.apache.tools.ant.types.ResourcegetStylesheet()
access the stylesheet to be used as a resource.

return
stylesheet as a resource

        String xslname = "junit-frames.xsl";
        if (NOFRAMES.equals(format)) {
            xslname = "junit-noframes.xsl";
        }
        if (styleDir == null) {
            // If style dir is not specified we have to retrieve
            // the stylesheet from the classloader
            URLResource stylesheet = new URLResource();
            URL stylesheetURL = getClass().getClassLoader().getResource(
                    "org/apache/tools/ant/taskdefs/optional/junit/xsl/" + xslname);
            stylesheet.setURL(stylesheetURL);
            return stylesheet;
        }
        // If we are here, then the style dir is here and we
        // should read the stylesheet from the filesystem
        FileResource stylesheet = new FileResource();
        File stylesheetFile = new File(styleDir, xslname);
        stylesheet.setFile(stylesheetFile);
        return stylesheet;
    
protected java.lang.StringgetStylesheetSystemId()
Get the systemid of the appropriate stylesheet based on its name and styledir. If no styledir is defined it will load it as a java resource in the xsl child package, otherwise it will get it from the given directory.

return
system ID of the stylesheet.
throws
IOException thrown if the requested stylesheet does not exist.

        String xslname = "junit-frames.xsl";
        if (NOFRAMES.equals(format)) {
            xslname = "junit-noframes.xsl";
        }
        if (styleDir == null) {
            URL url = getClass().getResource("xsl/" + xslname);
            if (url == null) {
                throw new FileNotFoundException("Could not find jar resource " + xslname);
            }
            return url.toExternalForm();
        }
        File file = new File(styleDir, xslname);
        if (!file.exists()) {
            throw new FileNotFoundException("Could not find file '" + file + "'");
        }
        return JAXPUtils.getSystemId(file);
    
public voidsetExtension(java.lang.String ext)
set the extension of the output files

param
ext extension.

        task.log("extension is not used anymore", Project.MSG_WARN);
    
public voidsetFormat(org.apache.tools.ant.taskdefs.optional.junit.AggregateTransformer$Format format)
sets the format.

param
format Must be FRAMES or NOFRAMES

        this.format = format.getValue();
    
public voidsetStyledir(java.io.File styledir)
set the style directory. It is optional and will override the default xsl used.

param
styledir the directory containing the xsl files if the user would like to override with its own style.

        this.styleDir = styledir;
    
public voidsetTodir(java.io.File todir)
set the destination directory.

param
todir the destination directory

        this.toDir = todir;
    
public voidsetXmlDocument(org.w3c.dom.Document doc)
sets the input document.

param
doc input dom tree

        this.document = doc;
    
protected voidsetXmlfile(java.io.File xmlfile)
Set the xml file to be processed. This is a helper if you want to set the file directly. Much more for testing purposes.

param
xmlfile xml file to be processed
throws
BuildException if the document cannot be parsed.

        try {
            DocumentBuilder builder = privateDBFactory.newDocumentBuilder();
            InputStream in = new FileInputStream(xmlfile);
            try {
                Document doc = builder.parse(in);
                setXmlDocument(doc);
            } finally {
                in.close();
            }
        } catch (Exception e) {
            throw new BuildException("Error while parsing document: " + xmlfile, e);
        }
    
public voidtransform()
transformation

throws
BuildException exception if something goes wrong with the transformation.

        checkOptions();
        Project project = task.getProject();

        TempFile tempFileTask = new TempFile();
        tempFileTask.bindToOwner(task);

        XSLTProcess xsltTask = new XSLTProcess();
        xsltTask.bindToOwner(task);

        xsltTask.setXslResource(getStylesheet());

        // acrobatic cast.
        xsltTask.setIn(((XMLResultAggregator) task).getDestinationFile());
        File outputFile = null;
        if (format.equals(FRAMES)) {
            String tempFileProperty = getClass().getName() + String.valueOf(counter++);
            File tmp = FILE_UTILS.resolveFile(project.getBaseDir(),
                    project.getProperty("java.io.tmpdir"));
            tempFileTask.setDestDir(tmp);
            tempFileTask.setProperty(tempFileProperty);
            tempFileTask.execute();
            outputFile = new File(project.getProperty(tempFileProperty));
        } else {
            outputFile = new File(toDir, "junit-noframes.html");
        }
        xsltTask.setOut(outputFile);
        for (Iterator i = params.iterator(); i.hasNext();) {
            XSLTProcess.Param param = (XSLTProcess.Param) i.next();
            XSLTProcess.Param newParam = xsltTask.createParam();
            newParam.setProject(task.getProject());
            newParam.setName(param.getName());
            newParam.setExpression(param.getExpression());
        }
        XSLTProcess.Param paramx = xsltTask.createParam();
        paramx.setProject(task.getProject());
        paramx.setName("output.dir");
        paramx.setExpression(toDir.getAbsolutePath());
        final long t0 = System.currentTimeMillis();
        try {
            xsltTask.execute();
        } catch (Exception e) {
            throw new BuildException("Errors while applying transformations: "
                    + e.getMessage(), e);
        }
        final long dt = System.currentTimeMillis() - t0;
        task.log("Transform time: " + dt + "ms");
        if (format.equals(FRAMES)) {
            Delete delete = new Delete();
            delete.bindToOwner(task);
            delete.setFile(outputFile);
            delete.execute();
        }