Example C.2. XSLT Transformation for OpenOffice.org documents

/*
 * OOoTransform.java
 * (c) 2003-2004 J. David Eisenberg
 * Licensed under LGPL
 *
 * Program purpose: to perform an XSLT transformation
 * on a member of an OpenOffice.org document, either
 * after unzipping or while still in its zipped state.
 * Output may go to a normal file or a zipped file.
 */

import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerConfigurationException;

import org.xml.sax.XMLReader;
import org.xml.sax.InputSource;
import org.xml.sax.ContentHandler;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.XMLReaderFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import java.util.jar.JarInputStream;
import java.util.jar.JarOutputStream;
import java.util.jar.JarEntry;
import java.util.Vector;
import java.util.zip.ZipException;

public class OOoTransform
{
    String  inputFileName = null;   // input file name, or member name...
    String  inputOOoName = null;    // ...if an OOo input file is given
    String  outputFileName = null;  // output file name, or member name...
    String  outputOOoName = null;   // ...if an OOo output file is given
    String  xsltFileName = null;    // XSLT file is always a regular file

    Vector  params = new Vector();  // parameters to be passed to transform

    public OOoTransform( )
    {
        /* I thought I needed a constructor here */
    }
    
    public void doTransform( )
    throws TransformerException, TransformerConfigurationException, 
         SAXException, ZipException, IOException       
    {
        /* Set up the XSLT transformation based on the XSLT file */
        File xsltFile = new File( xsltFileName );
        StreamSource streamSource = new StreamSource( xsltFile );
        TransformerFactory tFactory = TransformerFactory.newInstance(); 
        Transformer transformer = tFactory.newTransformer( streamSource );

        /* Set up parameters for transform */
        for (int i=0; i < params.size(); i += 2)
        {
            transformer.setParameter((String) params.elementAt(i),
                (String) params.elementAt(i + 1));
        }

        /* Create an XML reader which will ignore the <!DOCTYPE office.dtd> */
        XMLReader reader = XMLReaderFactory.createXMLReader();
        reader.setEntityResolver( new ResolveOfficeDTD() );
        
        InputSource inputSource;

        if (inputOOoName == null)
        {
            /* This is an unpacked file. */
            inputSource =
                new InputSource( new FileInputStream( inputFileName ) );
        }
        else
        {
            /* The input file should be a member of an OOo file.
               Check to see if the input file name really exists
               within the JAR file */
            JarInputStream jarStream =
                new JarInputStream( new FileInputStream( inputOOoName ),
                    false );
            JarEntry jarEntry;
            while ( (jarEntry = jarStream.getNextJarEntry() ) != null &&
                !(inputFileName.equals(jarEntry.getName()) ) )
                // do nothing
                ;
            inputSource = new InputSource( jarStream );
        }
        
        SAXSource saxSource = new SAXSource( reader, inputSource );
        saxSource.setSystemId( inputFileName );

        if (outputOOoName == null)
        {
            /* We want a regular file as output */
            FileOutputStream outputStream =
                new FileOutputStream( outputFileName );
            transformer.transform( saxSource, 
                new StreamResult( outputStream ) );
        }
        else
        {
            /* The output file name is the name of a member of
               a JAR file (which we will build without a manifest) */
            JarOutputStream jarStream =
                new JarOutputStream( new FileOutputStream( outputOOoName ) );
            JarEntry jarEntry = new JarEntry( outputFileName );
            jarStream.putNextEntry( jarEntry );
            transformer.transform( saxSource, 
                new StreamResult( jarStream ) );
                
            /* You must close the member file and the JAR file
               to complete the file */
            jarStream.closeEntry();
            jarStream.close();
        }
    }

    /* Check to see if the command line arguments make sense */
    public void checkArgs( String[] args )
    {
        int     i;
        
        if (args.length == 0)
        {
            showUsage( );
            System.exit( 1 );
        }
        i = 0;
        while ( i < args.length )
        {
            if (args[i].equalsIgnoreCase("-in"))
            {
                if ( i+1 >= args.length)
                {
                    badParam("-in");
                }
                inputFileName = args[i+1];
                i += 2;
            }
            else if (args[i].equalsIgnoreCase("-out"))
            {
                if ( i+1 >= args.length)
                {
                    badParam("-out");
                }
                outputFileName = args[i+1];
                i += 2;
            }
            else if (args[i].equalsIgnoreCase("-xsl"))
            {
                if ( i+1 >= args.length)
                {
                    badParam("-xsl");
                }
                xsltFileName = args[i+1];
                i += 2;
            }
            else if (args[i].equalsIgnoreCase("-inooo"))
            {
                if ( i+1 >= args.length)
                {
                    badParam("-inOOo");
                }
                inputOOoName = args[i+1];
                i += 2;
            }
            else if (args[i].equalsIgnoreCase("-outooo"))
            {
                if ( i+1 >= args.length)
                {
                    badParam("-outOOo");
                }
                outputOOoName = args[i+1];
                i += 2;
            }
            else if (args[i].equalsIgnoreCase("-param"))
            {
                if ( i+2 >= args.length)
                {
                    badParam("-param");
                }
                params.addElement( args[i+1] );
                params.addElement( args[i+2] );
                i += 3;
            }
            else
            {
                System.out.println( "Unknown argument " + args[i] );
                System.exit( 1 );
            }
        }
        
        if (inputFileName == null)
        {
            System.out.println("No input file name specified.");
            System.exit( 1 );
        }
        if (outputFileName == null)
        {
            System.out.println("No output file name specified.");
            System.exit( 1 );
        }
        if (xsltFileName == null)
        {
            System.out.println("No XSLT file name specified.");
            System.exit( 1 );
        }
    }

    /* If not enough arguments for a parameter, show error and exit */
    public void badParam( String paramName )
    {
        System.out.println("Not enough parameters to " + paramName);
        System.exit(1);
    }
    
    /* If no arguments are provided, show this brief help section */
    public void showUsage( )
    {
        System.out.println("Usage: OOoTransform options");
        System.out.println("Options:");
        System.out.println("   -in inputFilename");
        System.out.println("   -xsl transformFilename");
        System.out.println("   -out outputFilename");
        System.out.println("If the input filename is within an OOo file, then:");
        System.out.println("   -inOOo inputOOoFileName");
        System.out.println("If you wish to output an OOo file, then:");
        System.out.println("   -outOOo outputOOoFileName");
        System.out.println( );
        System.out.println("Argument names are case-insensitive.");
    }

    public static void main(String[] args)
    {
        OOoTransform transformApp = new OOoTransform( );
        transformApp.checkArgs( args );
        try {
            transformApp.doTransform( );
        }
        catch (Exception e)
        {
            System.out.println("Unable to transform");
            System.out.println(e.getMessage( ));
        }
    }
}