/*
    * @(#)$Id: AbstractJavafxdocMojo.java 69 2010-05-13 14:21:43Z nderwin $
    *
    * Licensed 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.
   * under the License.
   */
  
  package net.sf.jfxdplugin;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Properties;
  import java.util.ResourceBundle;
  import java.util.regex.PatternSyntaxException;
  import org.apache.commons.lang.SystemUtils;
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.versioning.ArtifactVersion;
  import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.reporting.MavenReportException;
  import org.apache.maven.toolchain.Toolchain;
  import org.apache.maven.toolchain.ToolchainManager;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.ReaderFactory;
  import org.codehaus.plexus.util.StringUtils;
  import org.codehaus.plexus.util.cli.CommandLineException;
  import org.codehaus.plexus.util.cli.CommandLineUtils;
  import org.codehaus.plexus.util.cli.Commandline;
  import org.codehaus.plexus.util.cli.DefaultConsumer;
  
  /**
   * Base class for the Javafxdoc mojo.  This class contains the majority of the
   * mojo functionality.
   * <p>
   * Based on the Maven Javadoc Plugin version 2.6.
   *
   * @author Nathan Erwin
   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
   * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
   * @version $Revision: 69 $ $Date: 2010-05-13 10:21:43 -0400 (Thu, 13 May 2010) $
   * @since 1.0
   * @see <a href="http://maven.apache.org/plugins/maven-javadoc-plugin/">
   * http://maven.apache.org/plugins/maven-javadoc-plugin/</a>
   * @requiresDependencyResolution compile
   */
  public abstract class AbstractJavafxdocMojo extends AbstractMojo {
  
      /**
       * The default Javafxdoc API URLs according to the
       * <a href="http://java.sun.com/reference/api/index.html">Sun/Oracle API
       * Specifications</a>.
       * <pre>
       * &lt;javaFXApiLinks&gt;
       *   &lt;property&gt;
       *     &lt;name&gt;api_1.0&lt;/name&gt;
       *     &lt;value&gt;http://java.sun.com/javafx/1/docs/api/&lt;/value&gt;
       *   &lt;/property&gt;
       *   &lt;property&gt;
       *     &lt;name&gt;api_1.1&lt;/name&gt;
       *     &lt;value&gt;http://java.sun.com/javafx/1.1/docs/api/&lt;/value&gt;
       *   &lt;/property&gt;
       *   &lt;property&gt;
       *     &lt;name&gt;api_1.2&lt;/name&gt;
       *     &lt;value&gt;http://java.sun.com/javafx/1.2/docs/api/&lt;/value&gt;
       *   &lt;/property&gt;
       *   &lt;property&gt;
       *     &lt;name&gt;api_1.3&lt;/name&gt;
       *     &lt;value&gt;http://java.sun.com/javafx/1.3/docs/api/&lt;/value&gt;
       * &lt;/javaFXApiLinks&gt;
       * </pre>
       */
      public static final Properties DEFAULT_JAVA_API_LINKS = new Properties();
      /**
       * The Javafxdoc script file name when the <code>debug</code> parameter is
       * on, i.e. javafxdoc.bat or javafxdoc.sh.
       */
      protected static final String DEBUG_JAVAFXDOC_SCRIPT_NAME;
 
     static {
         String name = "javafxdoc.sh";
 
         if (SystemUtils.IS_OS_WINDOWS) {
             name = "javafxdoc.bat";
         }
 
         DEBUG_JAVAFXDOC_SCRIPT_NAME = name;
     }
     /**
      * The <code>files</code> file name in the output directory when calling
      * <code>javafxdoc.exe(or .sh) [&#x40;options] [packagenames] [sourcefiles]
      * [&#x40;files]</code>.
      */
     protected static final String FILES_FILE_NAME = "files";
     /**
      * The <code>options</code> file name in the output directory when calling
      * <code>javafxdoc.exe(or .sh) [&#x40;options] [packagenames] [sourcefiles]
      * [&#x40;files]</code>.
      */
     protected static final String OPTIONS_FILE_NAME = "options";
     /**
      * The default JavaFX version (1.0) to use if no other viable version can be
      * found.
      */
     protected static final float DEFAULT_JAVAFX_VERSION = 1.0f;
     /**
      * For Javafxdoc options that appear since JavaFX 1.3.
      */
     protected static final float SINCE_JAVAFXDOC_1_3 = 1.3f;
     /** @component */
     private ToolchainManager toolchainManager;
     // Mojo parameters in alphabetical order
     /**
      * Set this to 'true' to debug the Javafxdoc plugin. With this,
      * the execution script and 'files' files are provided.
      * <br/>
      *
      * @parameter expression="${debug}" default-value="false"
      */
     private boolean debug = false;
     /**
      * Specifies whether the build will continue even if there are errors.
      *
      * @parameter expression="${failOnError}" default-value="false"
      */
     private boolean failOnError = false;
     /**
      * Sets the absolute path of the Javafxdoc Tool executable to use. A mere
      * directory specification is sufficient to have the plugin use "javafxdoc"
      * or "javafxdoc.exe" respectively from this directory.
      *
      * @parameter expression="${javafxdocExecutable}"
      */
     private String javafxdocExecutable;
     /**
      * The Maven Project Object.
      *
      * @parameter expression="${project}"
      * @required
      * @readonly
      */
     private MavenProject project;
     /**
      * The current build session instance. This is used for
      * toolchain manager API calls.
      *
      * @parameter expression="${session}"
      * @required
      * @readonly
      */
     private MavenSession session;
     //
     // Javafxdoc parameters in alphabetical order
     //
     /**
      * Passes the specified flag directly to the runtime system.
      * Example:
      * <pre>
      * &lt;additionalJOptions&gt;
      *  &lt;additionalJOption&gt;-Xss128m&lt;/additionalJOption&gt;
      * &lt;/additionalJOptions&gt;
      * </pre>
      *
      * @parameter
      */
     private String[] additionalJOptions;
     /**
      * Specifies the paths where the boot classes reside.  The paths
      * are separated with a colon (<code>:</code>) on Solaris and a semi-colon
      * (<code>;</code>) on Windows.
      *
      * @parameter expression="${bootclasspath}"
      */
     private String bootclasspath;
     /**
      * Uses the sentence break iterator to determine the end of the first
      * sentence.
      *
      * @parameter expression="${breakiterator}" default-value="false"
      */
     private boolean breakiterator = false;
     /**
      * Specifies the class file that starts the doclet used in generating the
      * documentation.
      *
      * @parameter expression="${doclet}"
      */
     private String doclet;
     /**
      * Specifies the path to the doclet starting class file (specified with
      * the <code>-doclet</code> option) and any jar files it depends on.
      *
      * @parameter expression="${docletPath}"
      */
     private String docletPath;
     /**
      * Specifies the encoding name of the source files.  If not specificed, the
      * encoding value will be the value of the
      * <code>project.build.sourceEncoding</code> property.
      *
      * @parameter expression="${encoding}" default-value="${project.build.sourceEncoding}"
      */
     private String encoding;
     /**
      * Unconditionally excludes the specified packages and their subpackages.
      * Multiple packages can be separated by colons (<code>:</code>).
      *
      * @parameter expression="${excludePackageNames}"
      */
     private String excludePackageNames;
     /**
      * Specifies the directories where extension classes reside.  Separate
      * directories in dirlist with a colon (<code>:</code>) on Solaris and a
      * semi-colon (<code>;</code>) on Windows.
      *
      * @parameter expression="${extdirs}"
      */
     private String extdirs;
     /**
      * Specifies the locale that javafxdoc uses when generating documentation.
      *
      * @parameter expression="${locale}"
      */
     private String locale;
     /**
      * Specifies the JavaFX platform.  Valid values are "desktop" (default),
      * "mobile", or "tv" (as of JavaFX 1.3).
      *
      * @parameter expression="${profile}" default-value="desktop"
      */
     private String profile = "desktop";
     /**
      * Shuts off status messages.  Maybe.
      *
      * @parameter expression="${quiet}" default-value="false"
      */
     private boolean quiet = false;
     /**
      * Specifies the access level for classes and members to show in the
      * JavaFXDocs. Possible values are
      * <ul>
      * <li>public (Show only public classes and members)</li>
      * <li>protected (Show protected/public classes and members (default))</li>
      * <li>package (Show package/protected/public classes and members)</li>
      * <li>private (Show all classes and members)</li>
      * </ul>
      * <br/>
      *
      * @parameter expression="${show}" default-value="protected"
      */
     private String show = "protected";
     /**
      * Provides source compatability with the specified release.
      *
      * @parameter expression="${source}"
      */
     private String source;
     /**
      * Specifies the source paths where the subpackages are located.  The paths
      * are separated with a colon (<code>:</code>) on Solaris and a semi-colon
      * (<code>;</code>) on Windows.
      *
      * @parameter expression="${sourcePath}"
      */
     private String sourcePath;
     /**
      * Generates documentation from source files in the specified packages and
      * recursively in their subpackages.
      *
      * @parameter expression="${subpackages}"
      */
     private String subpackages;
     /**
      * Provides more detailed messages while Javafxdoc is running.
      *
      * @parameter expression="${verbose}" default-value="false"
      */
     private boolean verbose = false;
     //
     // Standard doclet parameters in alphabetical order
     //
     /**
      * Prevents generating the HTML files for the documentation.
      *
      * @parameter expression="${nohtml}" default-value="false"
      */
     private boolean nohtml = false;
     /**
      * Specifies the destination directory where javafxdoc saves the generated
      * HTML files.
      *
      * @parameter expression="${outputDirectory}" default-value="${project.build.directory}/apidocs"
      */
     private File outputDirectory;
     /**
      * Specifies the XML output file.
      *
      * @parameter expression="${outputFile}"
      */
     private File outputFile;
     /**
      * Specifies the XSL file to use for transforming the documentation.
      *
      * @parameter expression="${xsltfile}"
      */
     private File xsltfile;
     /**
      * Specifies the master CSS file for the HTML output.
      *
      * @parameter expression="${mastercss}"
      */
     private String mastercss;
     /**
      * Specifies an additional CSS file for the HTML output.
      *
      * @parameter expression="${extracss}"
      */
     private String extracss;
     /**
      * Specifies an additional JavaScript file for the HTML output.
      *
      * @parameter expression="${extrajs}"
      */
     private String extrajs;
     /**
      * Passes the specified xsl parameter to the xsl transformer.
      * Example:
      * <pre>
      * &lt;additionalXslOptions&gt;
      *  &lt;additionalXslOption&gt;extra-js=xtra.js&lt;/additionalXslOption&gt;
      * &lt;/additionalXslOptions&gt;
      * </pre>
      *
      * @parameter
      */
     private String[] additionalXslOptions;
     /**
      * Specifies additional XML input files that contain package/class
      * information to be transformed into the HTML output.
      *
      * @parameter
      */
     private File[] inputFiles;
     private Locale cachedLocale;
     private float javafxdocVersion = DEFAULT_JAVAFX_VERSION;
 
     /**
      * Returns the additional -J option value.
      *
      * @return the additional -J option value
      */
     public String[] getAdditionalJOptions() {
         return additionalJOptions;
     }
 
     /**
      * Specifies the additional -J option value.
      *
      * @param additionalJOptions the additional -J option value
      */
     public void setAdditionalJOptions(final String[] additionalJOptions) {
         this.additionalJOptions = additionalJOptions;
     }
 
     /**
      * Returns the additional Xsl options value.
      *
      * @return the additional Xsl options value
      */
     public String[] getAdditionalXslOptions() {
         return additionalXslOptions;
     }
 
     /**
      * Specifies the additional Xsl option value.
      *
      * @param additionalXslOptions the additional Xsl option value
      */
     public void setAdditionalXslOptions(final String[] additionalXslOptions) {
         this.additionalXslOptions = additionalXslOptions;
     }
 
     /**
      * Returns the boot class path.
      *
      * @return the boot class path
      */
     public String getBootclasspath() {
         return bootclasspath;
     }
 
     /**
      * Specifies the boot class path.
      *
      * @param bootclasspath the boot class path
      */
     public void setBootclasspath(final String bootclasspath) {
         this.bootclasspath = bootclasspath;
     }
 
     /**
      * Returns whether the sentence break iterator is used.
      *
      * @return whether the sentence break iterator is used
      */
     public boolean isBreakiterator() {
         return breakiterator;
     }
 
     /**
      * Specifies whether the sentence break iterator is used.
      *
      * @param breakiterator whether the sentence break iterator is used
      */
     public void setBreakiterator(final boolean breakiterator) {
         this.breakiterator = breakiterator;
     }
 
     /**
      * Returns whether the plugin is in debug mode.
      *
      * @return whether the plugin is in debug mode
      */
     public boolean isDebug() {
         return debug;
     }
 
     /**
      * Specifies whether the plugin is in debug mode.
      *
      * @param debug whether the plugin is in debug mode
      */
     public void setDebug(final boolean debug) {
         this.debug = debug;
     }
 
     /**
      * Returns the doclet for HTML generation.
      *
      * @return the doclet for HTML generation
      */
     public String getDoclet() {
         return doclet;
     }
 
     /**
      * Specifies the doclet for HTML generation.
      *
      * @param doclet the doclet for HTML generation
      */
     public void setDoclet(final String doclet) {
         this.doclet = doclet;
     }
 
     /**
      * Returns the path to the doclet for HTML generation.
      *
      * @return the path to the doclet for HTML generation
      */
     public String getDocletPath() {
         return docletPath;
     }
 
     /**
      * Specifies the path to the doclet for HTML generation.
      *
      * @param docletPath the path to the doclet for HTML generation
      */
     public void setDocletPath(final String docletPath) {
         this.docletPath = docletPath;
     }
 
     /**
      * Returns the output encoding.
      *
      * @return the output encoding
      */
     public String getEncoding() {
         return encoding;
     }
 
     /**
      * Specifies the output encoding.
      *
      * @param encoding the output encoding
      */
     public void setEncoding(final String encoding) {
         this.encoding = encoding;
     }
 
     /**
      * Returns the list of package names to exclude.
      *
      * @return the list of package names to exclude
      */
     public String getExcludePackageNames() {
         return excludePackageNames;
     }
 
     /**
      * Specifies the list of package names to exclude.
      *
      * @param excludePackageNames the list of package names to exclude
      */
     public void setExcludePackageNames(final String excludePackageNames) {
         this.excludePackageNames = excludePackageNames;
     }
 
     /**
      * Returns the extension directories.
      *
      * @return the extension directories
      */
     public String getExtdirs() {
         return extdirs;
     }
 
     /**
      * Specifies the extension directories.
      *
      * @param extdirs the extension directories
      */
     public void setExtdirs(final String extdirs) {
         this.extdirs = extdirs;
     }
 
     /**
      * Returns the extra CSS file to use.
      *
      * @return the extra CSS file to use
      */
     public String getExtracss() {
         return extracss;
     }
 
     /**
      * Specifies the extra CSS file to use.
      *
      * @param extracss the extra CSS file to use
      */
     public void setExtracss(final String extracss) {
         this.extracss = extracss;
     }
 
     /**
      * Returns the extra JavaScript file to use.
      *
      * @return the extra JavaScript file to use
      */
     public String getExtrajs() {
         return extrajs;
     }
 
     /**
      * Specifies the extra JavaScript file to use.
      *
      * @param extrajs the extra JavaScript file to use
      */
     public void setExtrajs(final String extrajs) {
         this.extrajs = extrajs;
     }
 
     /**
      * Returns whether the plugin fails on errors.
      *
      * @return whether the plugin fails on errors
      */
     public boolean isFailOnError() {
         return failOnError;
     }
 
     /**
      * Specifies whether the plugin fails on errors.
      *
      * @param failOnError whether the plugin fails on errors
      */
     public void setFailOnError(final boolean failOnError) {
         this.failOnError = failOnError;
     }
 
     /**
      * Returns the XML input file.
      *
      * @return the XML input file
      */
     public File[] getInputFiles() {
         return inputFiles;
     }
 
     /**
      * Specifies the XML input file.
      *
      * @param inputFiles the XML input file
      */
     public void setInputFiles(final File[] inputFiles) {
         this.inputFiles = inputFiles;
     }
 
     /**
      * Returns the location of the Javafxdoc executable.
      *
      * @return the location of the Javafxdoc executable
      */
     public String getJavafxdocExecutable() {
         return javafxdocExecutable;
     }
 
     /**
      * Specifies the location of the Javafxdoc executable.
      *
      * @param javafxdocExecutable the location of the Javafxdoc executable
      */
     public void setJavafxdocExecutable(final String javafxdocExecutable) {
         this.javafxdocExecutable = javafxdocExecutable;
     }
 
     /**
      * Returns the documentation locale.
      *
      * @return the documentation locale
      */
     public String getLocale() {
         if (null == locale) {
             locale = Locale.getDefault().toString();
         }
         return locale;
     }
 
     /**
      * Specifies the documentation locale.
      *
      * @param locale the documentation locale
      */
     public void setLocale(final String locale) {
         this.locale = locale;
         this.cachedLocale = null;
     }
 
     /**
      * Returns the location of the master CSS file.
      *
      * @return the location of the master CSS file
      */
     public String getMastercss() {
         return mastercss;
     }
 
     /**
      * Specifies the location of the master CSS file.
      *
      * @param mastercss the location of the master CSS file
      */
     public void setMastercss(final String mastercss) {
         this.mastercss = mastercss;
     }
 
     /**
      * Returns whether HTML files are generated.
      *
      * @return whether HTML files are generated
      */
     public boolean isNohtml() {
         return nohtml;
     }
 
     /**
      * Specifies whether HTML files are generated.
      *
      * @param nohtml whether HTML files are generated
      */
     public void setNohtml(final boolean nohtml) {
         this.nohtml = nohtml;
     }
 
     /**
      * Returns the output directory for the plugin.
      *
      * @return the output directory for the plugin
      */
     public File getOutputDirectory() {
         return outputDirectory;
     }
 
     /**
      * Specifies the output directory for the plugin.
      *
      * @param outputDirectory the output directory for the plugin
      */
     public void setOutputDirectory(final File outputDirectory) {
         this.outputDirectory = outputDirectory;
     }
 
     /**
      * Returns the XML output file.
      *
      * @return the XML output file
      */
     public File getOutputFile() {
         return outputFile;
     }
 
     /**
      * Specifies the XML output file.
      *
      * @param outputFile the XML output file
      */
     public void setOutputFile(final File outputFile) {
         this.outputFile = outputFile;
     }
 
     /**
      * Returns the Maven project object.
      *
      * @return the Maven project object
      */
     public MavenProject getProject() {
         return project;
     }
 
     /**
      * Specifies the Maven project object.
      *
      * @param project the Maven project object
      */
     public void setProject(final MavenProject project) {
         this.project = project;
     }
 
     /**
      * Returns the JavaFX platform name.
      *
      * @return the JavaFX platform name
      */
     public String getProfile() {
         return profile;
     }
 
     /**
      * Specifies the JavaFX platform name (desktop, mobile, tv).
      *
      * @param profile the JavaFX platform name
      */
     public void setProfile(String profile) {
         if ("desktop".equals(profile)) {
             this.profile = profile;
         } else if ("mobile".equals(profile)) {
             this.profile = profile;
         } else if ("tv".equals(profile)) {
             this.profile = profile;
         }
     }
 
     /**
      * Returns whether the plugin operates in quiet mode.
      *
      * @return whether the plugin operates in quiet mode
      */
     public boolean isQuiet() {
         return quiet;
     }
 
     /**
      * Specifies whether the plugin operates in quiet mode.
      *
      * @param quiet whether the plugin operates in quiet mode
      */
     public void setQuiet(final boolean quiet) {
         this.quiet = quiet;
     }
 
     /**
      * Returns the Maven session object.
      *
      * @return the Maven session object
      */
     public MavenSession getSession() {
         return session;
     }
 
     /**
      * Returns the visibility level to show in the documentation.
      *
      * @return the visibility level to show in the documentation
      */
     public String getShow() {
         return show;
     }
 
     /**
      * Specifies the visibility level to show in the documentation.
      *
      * @param show the visibility level to show in the documentation
      */
     public void setShow(final String show) {
         this.show = show;
     }
 
     /**
      * Returns the version of the source code.
      *
      * @return the version of the source code
 
      */
     public String getSource() {
         return source;
     }
 
     /**
      * Specifies the version of the source code.
      *
      * @param source the version of the source code
      */
     public void setSource(final String source) {
         this.source = source;
     }
 
     /**
      * Returns the path to the source code.
      *
      * @return the path to the source code
      */
     public String getSourcePath() {
         return sourcePath;
     }
 
     /**
      * Specifies the path to the source code.
      *
      * @param sourcePath the path to the source code
      */
     public void setSourcePath(final String sourcePath) {
         this.sourcePath = sourcePath;
     }
 
     /**
      * Returns the sub packages to document.
      *
      * @return the sub packages to document
      */
     public String getSubpackages() {
         return subpackages;
     }
 
     /**
      * Specifies the sub packages to document.
      *
      * @param subpackages the sub packages to document
      */
     public void setSubpackages(final String subpackages) {
         this.subpackages = subpackages;
     }
 
     /**
      * Returns the toolchain manager.
      *
      * @return the toolchain manager
      */
     protected ToolchainManager getToolchainManager() {
         return toolchainManager;
     }
 
     /**
      * Specifies the toolchain manager.
      *
      * @param toolchainManager the toolchain manager
      */
     protected void setToolchainManager(
             final ToolchainManager toolchainManager) {
         this.toolchainManager = toolchainManager;
     }
 
     /**
      * Returns whether the plugin operates in verbose mode.
      *
      * @return whether the plugin operates in verbose mode
      */
     public boolean isVerbose() {
         return verbose;
     }
 
     /**
      * Specifies whether the plugin operates in verbose mode.
      *
      * @param verbose whether the plugin operates in verbose mode
      */
     public void setVerbose(final boolean verbose) {
         this.verbose = verbose;
     }
 
     /**
      * Returns the XSL transformation file.
      *
      * @return the XSL transformation file
      */
     public File getXsltfile() {
         return xsltfile;
     }
 
     /**
      * Specifies the XSL transformation file.
      *
      * @param xsltfile the XSL transformation file
      */
     public void setXsltfile(final File xsltfile) {
         this.xsltfile = xsltfile;
     }
 
     /**
      * Method that indicates whether the javafxdoc can be generated or not.
      * If the project does not contain any source files and no subpackages are
      * specified, the plugin will terminate.
      *
      * @param files the project files
      * @return a boolean that indicates whether javafxdoc report can be
      * generated or not
      */
     protected boolean canGenerateReport(final List<String> files) {
         boolean canGenerate = true;
 
         if ((files.isEmpty()) && (StringUtils.isEmpty(getSubpackages()))) {
             canGenerate = false;
         }
 
         return canGenerate;
     }
 
     /**
      * Runs the report for the given parameters.
      *
      * @throws MavenReportException if problems are found during generation
      */
     protected void executeReport() throws MavenReportException {
         List<String> sourcePaths = getSourcePaths();
         List<String> files = getFiles(sourcePaths);
         if (!canGenerateReport(files)) {
             return;
         }
 
         List<String> packageNames = getPackageNames(sourcePaths, files);
         List<String> filesWithUnnamedPackages =
                 getFilesWithUnnamedPackages(sourcePaths, files);
 
         // find the javafxdoc executable
         String jExecutable;
         try {
             jExecutable = findJavafxdocExecutable();
         } catch (IOException ex) {
             throw new MavenReportException(ex.getMessage(), ex);
         }
 
         // set the JavaFX version
         setJavafxdocVersion(new File(jExecutable));
 
         // set up the output directory
         if (getOutputDirectory().exists()) {
             if (!getOutputDirectory().isDirectory()) {
                 throw new MavenReportException(formatMessage(
                         "report.javafxdoc.not.directory",
                         getOutputDirectory()));
             }
             if (!getOutputDirectory().canWrite()) {
                 throw new MavenReportException(formatMessage(
                         "report.javafxdoc.not.writable", getOutputDirectory()));
             }
         }
         getOutputDirectory().mkdirs();
 
         // create command line for Javafxdoc
         Commandline cmd = new Commandline();
         cmd.getShell().setQuotedArgumentsEnabled(false);
         cmd.setWorkingDirectory(getOutputDirectory().getAbsolutePath());
         cmd.setExecutable(jExecutable);
 
         // -J flag won't work in the options file
         if (null != getAdditionalJOptions()) {
             for (String opt : getAdditionalJOptions()) {
                 cmd.createArg().setValue("-J" + opt);
             }
         }
 
         // kind of a hack...  but "-profile blah" doesn't always work...
         cmd.createArg().setValue("-profile");
         if ((getJavafxdocVersion() < SINCE_JAVAFXDOC_1_3) && "tv".equals(
                 getProfile())) {
             cmd.createArg().setValue("desktop");
         } else {
             cmd.createArg().setValue(getProfile());
         }
 
         List<String> arguments = new ArrayList<String>();
 
         // wrap Javafxdoc options
         addJavafxdocOptions(arguments, sourcePaths);
 
         // wrap Standard doclet Options
         if (StringUtils.isEmpty(doclet)) {
             addStandardDocletOptions(arguments, getOutputDirectory());
         }
 
         addCommandLineOptions(cmd, arguments, getOutputDirectory());
 
         // write packages in the command line
         if (!packageNames.isEmpty()) {
             // write argfile file and include it in the command line
             addCommandLineArgFile(cmd, getOutputDirectory(),
                     filesWithUnnamedPackages);
         } else {
             // write argfile file and include it in the command line
             addCommandLineArgFile(cmd, getOutputDirectory(), files);
         }
 
         // Execute command line
         executeJavafxdocCommandLine(cmd, getOutputDirectory());
     }
 
     /**
      * Formats the messages from the resource bundle with the given arguments.
      *
      * @param message the message key in the resource bundle
      * @param args variable list of arguments to the message
      * @return a string containing the formatted message
      */
     protected String formatMessage(final String message, final Object... args) {
         String msg = getBundle(getLocaleObject()).getString(message);
         MessageFormat formatter = new MessageFormat("", getLocaleObject());
         formatter.applyPattern(msg);
         return formatter.format(args);
     }
 
     /**
      * Gets the resource bundle for the specified locale.
      *
      * @param specificLocale the locale of the currently generated report
      * @return the resource bundle for the requested locale
      */
     protected ResourceBundle getBundle(final Locale specificLocale) {
         Locale localeToUse = specificLocale;
 
         if (null == specificLocale) {
             localeToUse = Locale.getDefault();
         }
 
         return ResourceBundle.getBundle("javafxdoc-report", localeToUse,
                 getClass().getClassLoader());
     }
 
     /**
      * Method to get the files on the specified source paths.
      *
      * @param sourcePaths a List that contains the paths to the source files
      * @return a List that contains the specific path for every source file
      */
     protected List<String> getFiles(final List<String> sourcePaths) {
         List<String> files = new ArrayList<String>();
 
         if (StringUtils.isEmpty(getSubpackages())) {
             String[] excludedPackages = getExcludedPackages();
 
             for (String path : sourcePaths) {
                 File sourceDirectory = new File(path);
                 JavafxdocUtil.addFilesFromSource(files, sourceDirectory,
                         excludedPackages);
             }
         }
 
         return files;
     }
 
     /**
      * Returns the javafxdoc tool version.
      *
      * @return the javafxdoc tool version
      */
     protected float getJavafxdocVersion() {
         return javafxdocVersion;
     }
 
     /**
      * Constructs a Locale object from the specified <code>locale</code>.
      *
      * @return a Locale object based on the <code>locale</code> parameter
      * @see AbstractJavafxdocMojo#setLocale(java.lang.String)
      */
     protected Locale getLocaleObject() {
         if (null == cachedLocale) {
             String result[] = getLocale().split("_");
 
             String language = result[0];
 
             String country = "";
             if (result.length > 1) {
                 country = result[1];
             }
 
             String variant = "";
             if (result.length > 2) {
                 variant = result[2];
             }
 
             cachedLocale = new Locale(language, country, variant);
         }
 
         return cachedLocale;
     }
 
     /**
      * Returns the artifacts for the project.
      *
      * @param p the Maven project
      * @return the project artifacts
      */
     @SuppressWarnings("unchecked")
     protected List<Artifact> getProjectArtifacts(final MavenProject p) {
         return p.getCompileArtifacts();
     }
 
     /**
      * Method to get the source paths.  If no source path is specified in the
      * parameter, the compile source roots of the project will be used.
      *
      * @return a List of the project absolute source paths
      * @see JavafxdocUtil#pruneDirs(org.apache.maven.project.MavenProject,
      * java.util.List)
      */
     protected List<String> getSourcePaths() {
         List<String> sourcePaths;
 
         if (StringUtils.isEmpty(getSourcePath())) {
             sourcePaths = new ArrayList<String>(JavafxdocUtil.pruneDirs(
                     getProject(),
                     getProjectSourceRoots(getProject())));
 
             if (null != getProject().getExecutionProject()) {
                 sourcePaths.addAll(JavafxdocUtil.pruneDirs(getProject(),
                         getExecutionProjectSourceRoots(getProject())));
             }
         } else {
             String separator = "[:]";
             if (SystemUtils.IS_OS_WINDOWS) {
                 separator = "[;]";
             }
             sourcePaths = new ArrayList<String>(Arrays.asList(getSourcePath().
                     split(separator)));
         }
 
         sourcePaths = JavafxdocUtil.pruneDirs(getProject(), sourcePaths);
 
         return sourcePaths;
     }
 
     private void addArgIf(final List<String> arguments, final boolean b,
             final String value) {
         if (b) {
             arguments.add(value);
         }
     }
 
     private void addArgIfNotEmpty(final List<String> arguments,
             final String key, final String value) {
         if (StringUtils.isNotEmpty(value)) {
             if (StringUtils.isNotEmpty(key)) {
                 arguments.add(key);
             }
 
             String[] result = value.split(",");
             for (String token : result) {
                 token = token.trim();
 
                 if (StringUtils.isNotEmpty(token)) {
                     arguments.add(token);
                 }
             }
         }
     }
 
     private void addCommandLineArgFile(final Commandline cmd,
             final File outputDir, final List<String> files) throws
             MavenReportException {
         File argfileFile = new File(outputDir, FILES_FILE_NAME);
 
         try {
             FileUtils.fileWrite(argfileFile.getAbsolutePath(),
                     StringUtils.join(files.iterator(),
                     SystemUtils.LINE_SEPARATOR));
         } catch (IOException ex) {
             throw new MavenReportException(
                     formatMessage("report.javafxdoc.tempfile.write.fail",
                     argfileFile.getName()), ex);
         }
 
         cmd.createArg().setValue("@" + FILES_FILE_NAME);
 
         if (!isDebug()) {
             argfileFile.deleteOnExit();
         }
     }
 
     private void addCommandLineOptions(final Commandline cmd,
             final List<String> arguments, final File javadocOutputDirectory)
             throws MavenReportException {
         File optionsFile = new File(javadocOutputDirectory, OPTIONS_FILE_NAME);
 
         StringBuilder options = new StringBuilder();
         options.append(StringUtils.join(arguments.toArray(new String[0]),
                 SystemUtils.LINE_SEPARATOR));
 
         try {
             FileUtils.fileWrite(optionsFile.getAbsolutePath(),
                     StringUtils.join(arguments.iterator(),
                     SystemUtils.LINE_SEPARATOR));
         } catch (IOException ex) {
             throw new MavenReportException(
                     formatMessage("report.javafxdoc.tempfile.write.fail",
                     optionsFile.getName()), ex);
         }
 
         cmd.createArg().setValue("@" + OPTIONS_FILE_NAME);
 
         if (!isDebug()) {
             optionsFile.deleteOnExit();
         }
     }
 
     private void addJavafxdocOptions(final List<String> arguments,
             final List<String> sourcePaths) throws MavenReportException {
         validateJavafxdocOptions();
 
         // locale must be the first argument otherwise javafxdoc complains
         addArgIfNotEmpty(arguments, "-locale", getLocale());
 
         addArgIfNotEmpty(arguments, "-bootclasspath",
                 JavafxdocUtil.quotedPathArgument(getBootclasspath()));
 
         addArgIf(arguments, isBreakiterator(), "-breakiterator");
 
         addArgIfNotEmpty(arguments, "-classpath",
                 JavafxdocUtil.quotedPathArgument(getClassPath()));
 
         if (StringUtils.isNotEmpty(getDoclet())) {
             addArgIfNotEmpty(arguments, "-doclet",
                     JavafxdocUtil.quotedArgument(getDoclet()));
             addArgIfNotEmpty(arguments, "-docletpath",
                     JavafxdocUtil.quotedPathArgument(getDocletPath()));
         }
 
         if (StringUtils.isEmpty(getEncoding())) {
             getLog().warn(formatMessage("report.javafxdoc.encoding.warning",
                     ReaderFactory.FILE_ENCODING));
         }
         addArgIfNotEmpty(arguments, "-encoding", getEncoding());
 
         addArgIfNotEmpty(arguments, "-exclude",
                 getExcludedPackages(sourcePaths));
 
         addArgIfNotEmpty(arguments, "-extdirs",
                 JavafxdocUtil.quotedPathArgument(getExtdirs()));
 
         // "-public" || "-protected" || "-package" || "-private"
         addArgIf(arguments, StringUtils.isNotEmpty(getAccessLevel()),
                 getAccessLevel());
 
         addArgIf(arguments, isQuiet(), "-quiet");
 
         addArgIfNotEmpty(arguments, "-source", JavafxdocUtil.quotedArgument(
                 getSource()));
 
         if ((StringUtils.isEmpty(getSourcePath()))
                 && (StringUtils.isNotEmpty(getSubpackages()))) {
             setSourcePath(StringUtils.join(sourcePaths.iterator(),
                     File.pathSeparator));
         }
         if (StringUtils.isNotEmpty(getSourcePath())) {
             addArgIfNotEmpty(arguments, "-sourcepath",
                     JavafxdocUtil.quotedPathArgument(
                     buildSourcePath(sourcePaths)));
             addArgIfNotEmpty(arguments, "-subpackages", getSubpackages());
         }
 
         addArgIf(arguments, isVerbose(), "-verbose");
     }
 
     private void addStandardDocletOptions(final List<String> arguments,
             final File outputDir) {
 
         addArgIfNotEmpty(arguments, "-d",
                 JavafxdocUtil.quotedPathArgument(outputDir.toString()));
 
         addArgIfNotEmpty(arguments, "-extracss", JavafxdocUtil.
                 quotedPathArgument(getExtracss()));
 
         addArgIfNotEmpty(arguments, "-extrajs", JavafxdocUtil.
                 quotedPathArgument(getExtrajs()));
 
         if (null != getInputFiles()) {
             for (File file : getInputFiles()) {
                 addArgIfNotEmpty(arguments, "-i", JavafxdocUtil.
                         quotedPathArgument(file.toString()));
             }
         }
 
         addArgIfNotEmpty(arguments, "-mastercss", JavafxdocUtil.
                 quotedPathArgument(getMastercss()));
 
         addArgIf(arguments, isNohtml(), "-nohtml");
 
         if (null != getOutputFile()) {
             addArgIfNotEmpty(arguments, "-o",
                     JavafxdocUtil.quotedPathArgument(
                     getOutputFile().toString()));
         }
 
         if (null != getAdditionalXslOptions()) {
             for (String opt : getAdditionalXslOptions()) {
                 addArgIfNotEmpty(arguments, "-xsl:", opt);
             }
         }
 
         if (null != getXsltfile()) {
             addArgIfNotEmpty(arguments, "-xsltfile", JavafxdocUtil.
                     quotedPathArgument(getXsltfile().getAbsolutePath()));
         }
     }
 
     private String buildSourcePath(final List<String> sourcePaths) {
         String srcPath = null;
 
         if ((StringUtils.isEmpty(getSubpackages()))
                 || (StringUtils.isNotEmpty(getSourcePath()))) {
             srcPath = StringUtils.join(sourcePaths.iterator(),
                     File.pathSeparator);
         }
 
         return srcPath;
     }
 
     private void executeJavafxdocCommandLine(final Commandline cmd,
             final File outputDir) throws MavenReportException {
         String cmdLine = CommandLineUtils.toString(cmd.getCommandline()).
                 replaceAll("'", "");
 
         getLog().debug(cmdLine);
 
         if (isDebug()) {
             File commandLineFile = new File(outputDir,
                     DEBUG_JAVAFXDOC_SCRIPT_NAME);
             try {
                 FileUtils.fileWrite(commandLineFile.getAbsolutePath(), cmdLine);
 
                 if (!SystemUtils.IS_OS_WINDOWS) {
                     Runtime.getRuntime().exec(new String[]{
                                 "chmod",
                                 "a+x",
                                 commandLineFile.getAbsolutePath()
                             });
                 }
             } catch (IOException ex) {
                 throw new MavenReportException(
                         formatMessage("report.javafxdoc.debug.write.fail",
                         commandLineFile.getName()), ex);
             }
         }
 
         CommandLineUtils.StringStreamConsumer err =
                 new CommandLineUtils.StringStreamConsumer();
         try {
             int exitCode = CommandLineUtils.executeCommandLine(cmd,
                     new DefaultConsumer(), err);
 
             if (0 != exitCode) {
                 throw new MavenReportException(
                         formatMessage("report.javafxdoc.execution.fail",
                         exitCode, err.getOutput(), cmdLine));
             }
         } catch (CommandLineException ex) {
             throw new MavenReportException(
                     formatMessage("report.javafxdoc.execution.exception",
                     ex.getMessage()), ex);
         }
 
         if (StringUtils.isNotEmpty(err.getOutput())) {
             getLog().warn(formatMessage("report.javafxdoc.warnings"));
 
             String result[] = err.getOutput().split("\n");
             for (String token : result) {
                 getLog().warn(token.trim());
             }
         }
     }
 
     private String findJavafxdocExecutable() throws IOException {
         Toolchain tc = getToolchain();
 
         if (tc != null) {
             getLog().info(formatMessage("report.javafxdoc.toolchain.info", tc));
             if (getJavafxdocExecutable() != null) {
                 getLog().warn(
                         formatMessage("report.javafxdoc.toolchain.ignored",
                         getJavafxdocExecutable()));
             } else {
                 setJavafxdocExecutable(tc.findTool("javafxdoc"));
             }
         }
 
         String javafxdocCommand = "javafxdoc";
         if (SystemUtils.IS_OS_WINDOWS) {
             javafxdocCommand = javafxdocCommand + ".exe";
         }
 
         File javafxdocExe = null;
 
         // user defined javafxdoc
         if (StringUtils.isNotEmpty(getJavafxdocExecutable())) {
             javafxdocExe = new File(getJavafxdocExecutable());
 
             if (javafxdocExe.isDirectory()) {
                 javafxdocExe = new File(javafxdocExe, javafxdocCommand);
             }
 
             if (SystemUtils.IS_OS_WINDOWS
                     && javafxdocExe.getName().indexOf('.') < 0) {
                 javafxdocExe = new File(javafxdocExe.getPath() + ".exe");
             }
 
             if (!javafxdocExe.isFile()) {
                 throw new IOException(
                         formatMessage("report.javafxdoc.no.executable",
                         javafxdocExe));
             }
 
             return javafxdocExe.getAbsolutePath();
         }
 
         // try to find it from the JAVAFX_HOME environment variable
         Properties env = CommandLineUtils.getSystemEnvVars();
         String javafxHome = env.getProperty("JAVAFX_HOME");
 
         if (StringUtils.isEmpty(javafxHome)) {
             throw new IOException(formatMessage(
                     "report.javafxdoc.no.javafx.home"));
         }
 
         File homeFile = new File(javafxHome);
         if ((!homeFile.exists()) || (!homeFile.isDirectory())) {
             throw new IOException(formatMessage(
                     "report.javafxdoc.invalid.javafx.home", javafxHome));
         }
 
         javafxdocExe = new File(javafxHome + File.separator + "bin",
                 javafxdocCommand);
 
         if ((!javafxdocExe.exists()) || (!javafxdocExe.isFile())) {
             throw new IOException(
                     formatMessage("report.javafxdoc.invalid.executable",
                     javafxdocExe));
         }
 
         return javafxdocExe.getAbsolutePath();
     }
 
     private String getAccessLevel() {
         String accessLevel = "-protected";
         if ("public".equalsIgnoreCase(getShow())
                 || "protected".equalsIgnoreCase(getShow())
                 || "package".equalsIgnoreCase(getShow())
                 || "private".equalsIgnoreCase(getShow())) {
             accessLevel = "-" + getShow().toLowerCase();
         } else {
             getLog().error(formatMessage(
                     "report.javafxdoc.illegal.access.level", getShow()));
         }
 
         return accessLevel;
     }
 
     private String getClassPath() throws MavenReportException {
         List<File> classpathElements = new ArrayList<File>();
         Map<String, Artifact> compileArtifactMap =
                 new HashMap<String, Artifact>();
 
         classpathElements.addAll(getProjectBuildOutputDirs(getProject()));
 
         populateCompileArtifactMap(compileArtifactMap, getProjectArtifacts(
                 getProject()));
 
         for (String key : compileArtifactMap.keySet()) {
             Artifact a = compileArtifactMap.get(key);
             classpathElements.add(a.getFile());
         }
 
         // try to add in the jars in the SDK lib directory
         try {
             Properties env = CommandLineUtils.getSystemEnvVars();
             String javafxHome = env.getProperty("JAVAFX_HOME");
             File libDir = new File(javafxHome + File.separator + "lib");
             if ((libDir.exists()) && (libDir.isDirectory())) {
                 for (File f : libDir.listFiles()) {
                     if ((f.isFile()) && (f.getName().toLowerCase().endsWith(
                             ".jar"))) {
                         classpathElements.add(f);
                     } else {
                         if (f.isDirectory()) {
                             for (File sf : f.listFiles()) {
                                 if ((sf.isFile()) && (sf.getName().
                                         toLowerCase().endsWith(".jar"))) {
                                     classpathElements.add(sf);
                                 }
                             }
                         }
                     }
                 }
             }
         } catch (IOException ex) {
             // don't fail the process, just log it and move on
             getLog().error(ex.getMessage());
         }
 
         return StringUtils.join(classpathElements.iterator(),
                 File.pathSeparator);
     }
 
     private String[] getExcludedPackages() {
         String[] excludePackages = {};
 
         if (getExcludePackageNames() != null) {
             excludePackages = getExcludePackageNames().split("[ ,:;]");
         }
         for (int i = 0; i < excludePackages.length; i++) {
             excludePackages[i] = excludePackages[i].replace('.',
                     File.separatorChar);
         }
 
         return excludePackages;
     }
 
     private String getExcludedPackages(final List<String> sourcePaths) {
         List<String> excludedNames = null;
 
         if (StringUtils.isNotEmpty(getSourcePath()) && StringUtils.isNotEmpty(
                 getSubpackages())) {
             String[] excludedPackages = getExcludedPackages();
             String[] subpackagesList = subpackages.split("[:]");
 
             excludedNames = JavafxdocUtil.getExcludedNames(sourcePaths,
                     subpackagesList, excludedPackages);
         }
 
         String excludeArg = "";
         if ((StringUtils.isNotEmpty(getSubpackages()))
                 && (null != excludedNames) && (0 < excludedNames.size())) {
             // add the excludedpackage names
             for (String str : excludedNames) {
                 excludeArg = excludeArg + str + ":";
             }
             excludeArg = excludeArg.substring(0, excludeArg.length() - 1);
         }
 
         return excludeArg;
     }
 
     private List<String> getExecutionProjectSourceRoots(final MavenProject p) {
         if ("pom".equals(
                 p.getExecutionProject().getPackaging().toLowerCase())) {
             return Collections.emptyList();
         }
 
         return p.getExecutionProject().getCompileSourceRoots();
     }
 
     private List<String> getFilesWithUnnamedPackages(
             final List<String> sourcePaths, final List<String> files) {
         return getPackageNamesOrFilesWithUnnamedPackages(sourcePaths, files,
                 false);
     }
 
     private List<File> getProjectBuildOutputDirs(final MavenProject p) {
         if (StringUtils.isEmpty(p.getBuild().getOutputDirectory())) {
             return Collections.emptyList();
         }
 
         return Collections.singletonList(new File(p.getBuild().
                 getOutputDirectory()));
     }
 
     private List<String> getPackageNames(final List<String> sourcePaths,
             final List<String> files) {
         return getPackageNamesOrFilesWithUnnamedPackages(sourcePaths, files,
                 true);
     }
 
     private List<String> getPackageNamesOrFilesWithUnnamedPackages(
             final List<String> sourcePaths, final List<String> files,
             final boolean onlyPackageName) {
         List<String> returnList = new ArrayList<String>();
 
         if (!StringUtils.isEmpty(getSourcePath())) {
             return returnList;
         }
 
         for (String currentFile : files) {
             currentFile = currentFile.replace('\\', '/');
 
             for (String currentSourcePath : sourcePaths) {
                 currentSourcePath = currentSourcePath.replace('\\', '/');
 
                 if (!currentSourcePath.endsWith("/")) {
                     currentSourcePath += "/";
                 }
 
                 if (currentFile.indexOf(currentSourcePath) != -1) {
                     String packagename =
                             currentFile.substring(currentSourcePath.length()
                             + 1);
                     if (onlyPackageName && packagename.lastIndexOf("/") != -1) {
                         packagename = packagename.substring(0, packagename.
                                 lastIndexOf("/"));
                         packagename = packagename.replace('/', '.');
 
                         if (!returnList.contains(packagename)) {
                             returnList.add(packagename);
                         }
                     }
                     if ((!onlyPackageName)
                             && (packagename.lastIndexOf("/") == -1)) {
                         returnList.add(currentFile);
                     }
                 }
             }
         }
 
         return returnList;
     }
 
     private List<String> getProjectSourceRoots(final MavenProject p) {
         if ("pom".equals(p.getPackaging().toLowerCase())) {
             return Collections.emptyList();
         }
 
         return p.getCompileSourceRoots();
     }
 
     private Toolchain getToolchain() {
         Toolchain tc = null;
         if (getToolchainManager() != null) {
             tc = getToolchainManager().getToolchainFromBuildContext("jdk",
                     getSession());
         }
 
         return tc;
     }
 
     private void populateCompileArtifactMap(
             final Map<String, Artifact> compileArtifactMap,
             final Collection<Artifact> artifactList)
             throws MavenReportException {
         if (artifactList != null) {
             for (Artifact newArtifact : artifactList) {
                 File file = newArtifact.getFile();
 
                 if (null == file) {
                     throw new MavenReportException(
                             formatMessage("report.javafxdoc.artifact.error",
                             newArtifact.getGroupId(),
                             newArtifact.getArtifactId(),
                             newArtifact.getVersion()));
                 }
 
                 if (null != compileArtifactMap.get(newArtifact.
                         getDependencyConflictId())) {
                     Artifact oldArtifact =
                             compileArtifactMap.get(newArtifact.
                             getDependencyConflictId());
                     ArtifactVersion oldVersion = new DefaultArtifactVersion(
                             oldArtifact.getVersion());
                     ArtifactVersion newVersion = new DefaultArtifactVersion(
                             newArtifact.getVersion());
 
                     if (newVersion.compareTo(oldVersion) > 0) {
                         compileArtifactMap.put(newArtifact.
                                 getDependencyConflictId(),
                                 newArtifact);
                     }
                 } else {
                     compileArtifactMap.put(
                             newArtifact.getDependencyConflictId(), newArtifact);
                 }
             }
         }
     }
 
     private void setJavafxdocVersion(File file) {
         float version = DEFAULT_JAVAFX_VERSION;
 
         try {
             version = JavafxdocUtil.getJavafxdocVersion(file);
         } catch (CommandLineException ex) {
             getLog().warn(ex.getMessage());
         } catch (FileNotFoundException ex) {
             getLog().warn(ex.getMessage());
         } catch (PatternSyntaxException ex) {
             getLog().warn(ex.getMessage());
         } catch (IllegalArgumentException ex) {
             getLog().warn(ex.getMessage());
         }
 
         javafxdocVersion = version;
     }
 
     private void validateJavafxdocOptions() throws MavenReportException {
         // encoding
         if ((StringUtils.isNotEmpty(getEncoding()))
                 && (!JavafxdocUtil.validateEncoding(getEncoding()))) {
             throw new MavenReportException(formatMessage(
                     "report.javafxdoc.unsupported.encoding", getEncoding()));
         }
     }
 }