package org.apache.maven.doxia;
/*
* 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.BufferedInputStream;
import java.io.CharArrayWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.maven.doxia.logging.Log;
import org.apache.maven.doxia.logging.SystemStreamLog;
import org.apache.maven.doxia.parser.ParseException;
import org.apache.maven.doxia.parser.Parser;
import org.apache.maven.doxia.sink.Sink;
import org.apache.maven.doxia.sink.SinkFactory;
import org.apache.maven.doxia.util.ConverterUtil;
import org.apache.maven.doxia.wrapper.InputFileWrapper;
import org.apache.maven.doxia.wrapper.InputReaderWrapper;
import org.apache.maven.doxia.wrapper.OutputFileWrapper;
import org.apache.maven.doxia.wrapper.OutputStreamWrapper;
import org.codehaus.plexus.ContainerConfiguration;
import org.codehaus.plexus.DefaultContainerConfiguration;
import org.codehaus.plexus.DefaultPlexusContainer;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.PlexusContainerException;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.SelectorUtils;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.WriterFactory;
import org.codehaus.plexus.util.xml.XmlStreamReader;
import org.codehaus.plexus.util.xml.XmlUtil;
import org.codehaus.plexus.util.xml.pull.MXParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import com.ibm.icu.text.CharsetDetector;
import com.ibm.icu.text.CharsetMatch;
/**
* Default implementation of <code>Converter</code>
*
* @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
* @version $Id: DefaultConverter.java 784074 2009-06-12 11:14:35Z ltheussl $
*/
public class DefaultConverter
implements Converter
{
private static final String APT_PARSER = "apt";
private static final String CONFLUENCE_PARSER = "confluence";
private static final String DOCBOOK_PARSER = "docbook";
private static final String FML_PARSER = "fml";
private static final String TWIKI_PARSER = "twiki";
private static final String XDOC_PARSER = "xdoc";
private static final String XHTML_PARSER = "xhtml";
/** Supported input format, i.e. supported Doxia parser */
public static final String[] SUPPORTED_FROM_FORMAT =
{ APT_PARSER, CONFLUENCE_PARSER, DOCBOOK_PARSER, FML_PARSER, TWIKI_PARSER, XDOC_PARSER, XHTML_PARSER };
private static final String APT_SINK = "apt";
private static final String CONFLUENCE_SINK = "confluence";
private static final String DOCBOOK_SINK = "docbook";
private static final String FO_SINK = "fo";
private static final String ITEXT_SINK = "itext";
private static final String LATEX_SINK = "latex";
private static final String RTF_SINK = "rtf";
private static final String TWIKI_SINK = "twiki";
private static final String XDOC_SINK = "xdoc";
private static final String XHTML_SINK = "xhtml";
/** Supported output format, i.e. supported Doxia Sink */
public static final String[] SUPPORTED_TO_FORMAT =
{ APT_SINK, CONFLUENCE_SINK, DOCBOOK_SINK, FO_SINK, ITEXT_SINK, LATEX_SINK, RTF_SINK, TWIKI_SINK, XDOC_SINK,
XHTML_SINK };
/** Flag to format the generated files, actually only for XML based sinks. */
private boolean formatOutput;
/** Plexus container */
private PlexusContainer plexus;
/** Doxia logger */
private Log log;
/** {@inheritDoc} */
public void enableLogging( Log log )
{
this.log = log;
}
/**
* Returns a logger for this sink.
* If no logger has been configured, a new SystemStreamLog is returned.
*
* @return Log
*/
protected Log getLog()
{
if ( log == null )
{
log = new SystemStreamLog();
}
return log;
}
/** {@inheritDoc} */
public String[] getInputFormats()
{
return SUPPORTED_FROM_FORMAT;
}
/** {@inheritDoc} */
public String[] getOutputFormats()
{
return SUPPORTED_TO_FORMAT;
}
/** {@inheritDoc} */
public void convert( InputFileWrapper input, OutputFileWrapper output )
throws UnsupportedFormatException, ConverterException
{
if ( input == null )
{
throw new IllegalArgumentException( "input is required" );
}
if ( output == null )
{
throw new IllegalArgumentException( "output is required" );
}
try
{
startPlexusContainer();
}
catch ( PlexusContainerException e )
{
throw new ConverterException( "PlexusContainerException: " + e.getMessage(), e );
}
try
{
if ( input.getFile().isFile() )
{
parse( input.getFile(), input.getEncoding(), input.getFormat(), output );
}
else
{
List files;
try
{
files =
FileUtils.getFiles( input.getFile(), "**/*." + input.getFormat(),
StringUtils.join( FileUtils.getDefaultExcludes(), ", " ) );
}
catch ( IOException e )
{
throw new ConverterException( "IOException: " + e.getMessage(), e );
}
catch ( IllegalStateException e )
{
throw new ConverterException( "IllegalStateException: " + e.getMessage(), e );
}
for ( Iterator it = files.iterator(); it.hasNext(); )
{
File f = (File) it.next();
parse( f, input.getEncoding(), input.getFormat(), output );
}
}
}
finally
{
stopPlexusContainer();
}
}
/** {@inheritDoc} */
public void convert( InputReaderWrapper input, OutputStreamWrapper output )
throws UnsupportedFormatException, ConverterException
{
if ( input == null )
{
throw new IllegalArgumentException( "input is required" );
}
if ( output == null )
{
throw new IllegalArgumentException( "output is required" );
}
try
{
startPlexusContainer();
}
catch ( PlexusContainerException e )
{
throw new ConverterException( "PlexusContainerException: " + e.getMessage(), e );
}
try
{
Parser parser;
try
{
parser = ConverterUtil.getParser( plexus, input.getFormat(), SUPPORTED_FROM_FORMAT );
parser.enableLogging( log );
}
catch ( ComponentLookupException e )
{
throw new ConverterException( "ComponentLookupException: " + e.getMessage(), e );
}
if ( getLog().isDebugEnabled() )
{
getLog().debug( "Parser used: " + parser.getClass().getName() );
}
SinkFactory sinkFactory;
try
{
sinkFactory = ConverterUtil.getSinkFactory( plexus, output.getFormat(), SUPPORTED_TO_FORMAT );
}
catch ( ComponentLookupException e )
{
throw new ConverterException( "ComponentLookupException: " + e.getMessage(), e );
}
Sink sink;
try
{
sink = sinkFactory.createSink( output.getOutputStream(), output.getEncoding() );
}
catch ( IOException e )
{
throw new ConverterException( "IOException: " + e.getMessage(), e );
}
sink.enableLogging( log );
if ( getLog().isDebugEnabled() )
{
getLog().debug( "Sink used: " + sink.getClass().getName() );
}
parse( parser, input.getReader(), sink );
}
finally
{
stopPlexusContainer();
}
}
/** {@inheritDoc} */
public void setFormatOutput( boolean formatOutput )
{
this.formatOutput = formatOutput;
}
// ----------------------------------------------------------------------
// Private methods
// ----------------------------------------------------------------------
/**
* @param inputFile a not null existing file.
* @param inputEncoding a not null supported encoding or {@link InputFileWrapper#AUTO_ENCODING}
* @param inputFormat a not null supported format or {@link InputFileWrapper#AUTO_FORMAT}
* @param output not null OutputFileWrapper object
* @throws ConverterException if any
* @throws UnsupportedFormatException if any
*/
private void parse( File inputFile, String inputEncoding, String inputFormat, OutputFileWrapper output )
throws ConverterException, UnsupportedFormatException
{
if ( getLog().isDebugEnabled() )
{
getLog().debug(
"Parsing file from '" + inputFile.getAbsolutePath() + "' with the encoding '"
+ inputEncoding + "' to '" + output.getFile().getAbsolutePath()
+ "' with the encoding '" + output.getEncoding() + "'" );
}
if ( inputEncoding.equals( InputFileWrapper.AUTO_ENCODING ) )
{
inputEncoding = autoDetectEncoding( inputFile );
if ( getLog().isDebugEnabled() )
{
getLog().debug( "Auto detect encoding: " + inputEncoding );
}
}
if ( inputFormat.equals( InputFileWrapper.AUTO_FORMAT ) )
{
inputFormat = autoDetectFormat( inputFile, inputEncoding );
if ( getLog().isDebugEnabled() )
{
getLog().debug( "Auto detect input format: " + inputFormat );
}
}
Parser parser;
try
{
parser = ConverterUtil.getParser( plexus, inputFormat, SUPPORTED_FROM_FORMAT );
parser.enableLogging( log );
}
catch ( ComponentLookupException e )
{
throw new ConverterException( "ComponentLookupException: " + e.getMessage(), e );
}
File outputFile;
if ( output.getFile().exists() && output.getFile().isDirectory() )
{
outputFile = new File( output.getFile(), inputFile.getName() + "." + output.getFormat() );
}
else
{
if ( !SelectorUtils.match( "**.*", output.getFile().getName() ) )
{
// assume it is a directory
output.getFile().mkdirs();
outputFile = new File( output.getFile(), inputFile.getName() + "." + output.getFormat() );
}
else
{
output.getFile().getParentFile().mkdirs();
outputFile = output.getFile();
}
}
Reader reader;
try
{
if ( inputEncoding != null )
{
if ( parser.getType() == Parser.XML_TYPE )
{
reader = ReaderFactory.newXmlReader( inputFile );
}
else
{
reader = ReaderFactory.newReader( inputFile, inputEncoding );
}
}
else
{
reader = ReaderFactory.newPlatformReader( inputFile );
}
}
catch ( IOException e )
{
throw new ConverterException( "IOException: " + e.getMessage(), e );
}
SinkFactory sinkFactory;
try
{
sinkFactory = ConverterUtil.getSinkFactory( plexus, output.getFormat(), SUPPORTED_TO_FORMAT );
}
catch ( ComponentLookupException e )
{
throw new ConverterException( "ComponentLookupException: " + e.getMessage(), e );
}
Sink sink;
try
{
String outputEncoding;
if ( StringUtils.isEmpty( output.getEncoding() )
|| output.getEncoding().equals( OutputFileWrapper.AUTO_ENCODING ) )
{
outputEncoding = inputEncoding;
}
else
{
outputEncoding = output.getEncoding();
}
OutputStream out = new FileOutputStream( outputFile );
sink = sinkFactory.createSink( out, outputEncoding );
}
catch ( IOException e )
{
throw new ConverterException( "IOException: " + e.getMessage(), e );
}
sink.enableLogging( log );
if ( getLog().isDebugEnabled() )
{
getLog().debug( "Sink used: " + sink.getClass().getName() );
}
parse( parser, reader, sink );
if ( formatOutput && ( output.getFormat().equals( DOCBOOK_SINK ) || output.getFormat().equals( FO_SINK )
|| output.getFormat().equals( ITEXT_SINK ) || output.getFormat().equals( XDOC_SINK )
|| output.getFormat().equals( XHTML_SINK ) ) )
{
// format all xml files excluding docbook which is buggy
// TODO Add doc book format
if ( output.getFormat().equals( DOCBOOK_SINK ) || inputFormat.equals( DOCBOOK_PARSER ) )
{
return;
}
Reader r = null;
Writer w = null;
try
{
r = ReaderFactory.newXmlReader( outputFile );
CharArrayWriter caw = new CharArrayWriter();
XmlUtil.prettyFormat( r, caw );
w = WriterFactory.newXmlWriter( outputFile );
w.write( caw.toString() );
}
catch ( IOException e )
{
throw new ConverterException( "IOException: " + e.getMessage(), e );
}
finally
{
IOUtil.close( r );
IOUtil.close( w );
}
}
}
/**
* @param parser not null
* @param reader not null
* @param sink not null
* @throws ConverterException if any
*/
private void parse( Parser parser, Reader reader, Sink sink )
throws ConverterException
{
try
{
parser.parse( reader, sink );
}
catch ( ParseException e )
{
throw new ConverterException( "ParseException: " + e.getMessage(), e );
}
finally
{
IOUtil.close( reader );
sink.flush();
sink.close();
}
}
/**
* Start the Plexus container.
*
* @throws PlexusContainerException if any
*/
private void startPlexusContainer()
throws PlexusContainerException
{
if ( plexus != null )
{
return;
}
Map context = new HashMap();
context.put( "basedir", new File( "" ).getAbsolutePath() );
ContainerConfiguration containerConfiguration = new DefaultContainerConfiguration();
containerConfiguration.setName( "Doxia" );
containerConfiguration.setContext( context );
plexus = new DefaultPlexusContainer( containerConfiguration );
}
/**
* Stop the Plexus container.
*/
private void stopPlexusContainer()
{
if ( plexus == null )
{
return;
}
plexus.dispose();
plexus = null;
}
/**
* @param f not null file
* @return the detected encoding for f or <code>null</code> if not able to detect it.
* @throws IllegalArgumentException if f is not a file.
* @throws UnsupportedOperationException if could not detect the file encoding.
* @see {@link XmlStreamReader#getEncoding()} for xml files
* @see {@link CharsetDetector#detect()} for text files
*/
private static String autoDetectEncoding( File f )
{
if ( !f.isFile() )
{
throw new IllegalArgumentException( "The file '" + f.getAbsolutePath()
+ "' is not a file, could not detect encoding." );
}
Reader reader = null;
InputStream is = null;
try
{
if ( XmlUtil.isXml( f ) )
{
reader = ReaderFactory.newXmlReader( f );
return ( (XmlStreamReader) reader ).getEncoding();
}
is = new BufferedInputStream( new FileInputStream( f ) );
CharsetDetector detector = new CharsetDetector();
detector.setText( is );
CharsetMatch match = detector.detect();
return match.getName().toUpperCase( Locale.ENGLISH );
}
catch ( IOException e )
{
// nop
}
finally
{
IOUtil.close( reader );
IOUtil.close( is );
}
StringBuffer msg = new StringBuffer();
msg.append( "Could not detect the encoding for file: " );
msg.append( f.getAbsolutePath() );
msg.append( "\n Specify explicitly the encoding." );
throw new UnsupportedOperationException( msg.toString() );
}
/**
* Auto detect Doxia format for the given file depending:
* <ul>
* <li>the file name for TextMarkup based Doxia files</li>
* <li>the file content for XMLMarkup based Doxia files</li>
* </ul>
*
* @param f not null file
* @param encoding a not null encoding.
* @return the detected encoding from f.
* @throws IllegalArgumentException if f is not a file.
* @throws UnsupportedOperationException if could not detect the Doxia format.
*/
private static String autoDetectFormat( File f, String encoding )
{
if ( !f.isFile() )
{
throw new IllegalArgumentException( "The file '" + f.getAbsolutePath()
+ "' is not a file, could not detect format." );
}
for ( int i = 0; i < SUPPORTED_FROM_FORMAT.length; i++ )
{
String supportedFromFormat = SUPPORTED_FROM_FORMAT[i];
// Handle Doxia text files
if ( supportedFromFormat.equalsIgnoreCase( APT_PARSER )
&& isDoxiaFileName( f, supportedFromFormat ) )
{
return supportedFromFormat;
}
else if ( supportedFromFormat.equalsIgnoreCase( CONFLUENCE_PARSER )
&& isDoxiaFileName( f, supportedFromFormat ) )
{
return supportedFromFormat;
}
else if ( supportedFromFormat.equalsIgnoreCase( TWIKI_PARSER )
&& isDoxiaFileName( f, supportedFromFormat ) )
{
return supportedFromFormat;
}
// Handle Doxia xml files
String firstTag = getFirstTag( f );
if ( firstTag == null )
{
continue;
}
else if ( firstTag.equals( "article" )
&& supportedFromFormat.equalsIgnoreCase( DOCBOOK_PARSER ) )
{
return supportedFromFormat;
}
else if ( firstTag.equals( "faqs" )
&& supportedFromFormat.equalsIgnoreCase( FML_PARSER ) )
{
return supportedFromFormat;
}
else if ( firstTag.equals( "document" )
&& supportedFromFormat.equalsIgnoreCase( XDOC_PARSER ) )
{
return supportedFromFormat;
}
else if ( firstTag.equals( "html" )
&& supportedFromFormat.equalsIgnoreCase( XHTML_PARSER ) )
{
return supportedFromFormat;
}
}
StringBuffer msg = new StringBuffer();
msg.append( "Could not detect the Doxia format for file: " );
msg.append( f.getAbsolutePath() );
msg.append( "\n Specify explicitly the Doxia format." );
throw new UnsupportedOperationException( msg.toString() );
}
/**
* @param f not null
* @param format could be null
* @return <code>true</code> if the file name computes the format.
*/
private static boolean isDoxiaFileName( File f, String format )
{
if ( f == null )
{
throw new IllegalArgumentException( "f is required." );
}
Pattern pattern = Pattern.compile( "(.*?)\\." + format.toLowerCase( Locale.ENGLISH ) + "$" );
Matcher matcher = pattern.matcher( f.getName().toLowerCase( Locale.ENGLISH ) );
return matcher.matches();
}
/**
* @param xmlFile not null and should be a file.
* @return the first tag name if found, <code>null</code> in other case.
*/
private static String getFirstTag( File xmlFile )
{
if ( xmlFile == null )
{
throw new IllegalArgumentException( "xmlFile is required." );
}
if ( !xmlFile.isFile() )
{
throw new IllegalArgumentException( "The file '" + xmlFile.getAbsolutePath() + "' is not a file." );
}
Reader reader = null;
try
{
reader = ReaderFactory.newXmlReader( xmlFile );
XmlPullParser parser = new MXParser();
parser.setInput( reader );
int eventType = parser.getEventType();
while ( eventType != XmlPullParser.END_DOCUMENT )
{
if ( eventType == XmlPullParser.START_TAG )
{
return parser.getName();
}
eventType = parser.nextToken();
}
}
catch ( FileNotFoundException e )
{
return null;
}
catch ( XmlPullParserException e )
{
return null;
}
catch ( IOException e )
{
return null;
}
finally
{
IOUtil.close( reader );
}
return null;
}
}