////////////////////////////////////////////////////////////////////////////////

 //

 //                  ObjectLab is sponsoring QALab

 // 

 // Based in London, we are world leaders in the design and development 

 // of bespoke applications for the Securities Financing markets.

 // 

 // <a href="http://www.objectlab.co.uk/open">Click here to learn more</a>

 //           ___  _     _           _   _          _

 //          / _ \| |__ (_) ___  ___| |_| |    __ _| |__

 //         | | | | '_ \| |/ _ \/ __| __| |   / _` | '_ \

 //         | |_| | |_) | |  __/ (__| |_| |__| (_| | |_) |

 //          \___/|_.__// |\___|\___|\__|_____\__,_|_.__/

 //                   |__/

 //

 //                   http://www.ObjectLab.co.uk

 // ---------------------------------------------------------------------------

 //

 //QALab is released under the GNU General Public License.

 //

 //QALab: Collects QA Statistics from your build over time.

 //2005+, ObjectLab Ltd

 //

 //This library is free software; you can redistribute it and/or

 //modify it under the terms of the GNU General Public

 //License as published by the Free Software Foundation; either

 //version 2.1 of the License, or (at your option) any later version.

 //

 //This library is distributed in the hope that it will be useful,

 //but WITHOUT ANY WARRANTY; without even the implied warranty of

 //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 //General Public License for more details.

 //

 //You should have received a copy of the GNU General Public

 //License along with this library; if not, write to the Free Software

 //Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 //

 ////////////////////////////////////////////////////////////////////////////////

 package net.objectlab.qalab.exporter;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileWriter;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.StringWriter;

 import java.util.Locale;

 import java.util.Properties;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import net.objectlab.qalab.interfaces.QALabExporter;

 import net.objectlab.qalab.util.QALabTags;

 import net.objectlab.qalab.util.TaskLogger;

 import net.objectlab.qalab.util.Util;

 import org.apache.tools.ant.BuildException;

 import org.apache.xml.serialize.OutputFormat;

 import org.apache.xml.serialize.XMLSerializer;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.w3c.dom.Node;

 import org.w3c.dom.NodeList;

 import org.xml.sax.InputSource;

 import org.xml.sax.SAXException;

 /**

  * This is the main exporter to an XML file following the QALab DTD.

  * 

  * @author Benoit Xhenseval

  * @version $Revision$

  */

 public class QALabXMLExporter implements QALabExporter {

     private static final String XML_VERSION = "1.1";

     /**

      * If no qalab.xml is found, this will be the basis of a new one.

      */

     private static final String DTD_DEFINITION = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"

             + System.getProperty("line.separator") + "<!DOCTYPE qalab [" + System.getProperty("line.separator")

             + "<!ELEMENT qalab (summary, file*)>" + System.getProperty("line.separator")

             + "<!ATTLIST qalab version CDATA #REQUIRED> " + System.getProperty("line.separator")

             + "<!ELEMENT summary (summaryresult*)>" + System.getProperty("line.separator") + "<!ELEMENT file (result+)>"

             + System.getProperty("line.separator") + "<!ATTLIST file id ID #REQUIRED" + System.getProperty("line.separator")

             + "   path CDATA #REQUIRED>" + System.getProperty("line.separator") + "<!ELEMENT result EMPTY>"

             + System.getProperty("line.separator") + "<!ATTLIST result date CDATA #REQUIRED"

             + System.getProperty("line.separator") + "   statvalue CDATA #REQUIRED" + System.getProperty("line.separator")

             + "   type CDATA #REQUIRED>" + System.getProperty("line.separator") + "<!ELEMENT summaryresult EMPTY>"

             + System.getProperty("line.separator") + "<!ATTLIST summaryresult date CDATA #REQUIRED"

             + System.getProperty("line.separator") + "   statvalue CDATA #REQUIRED" + System.getProperty("line.separator")

             + "   filecount CDATA #REQUIRED" + System.getProperty("line.separator") + "   type CDATA #REQUIRED>"

             + System.getProperty("line.separator") + "]>" + System.getProperty("line.separator");

     private static final String EMPTY_FILE = DTD_DEFINITION + System.getProperty("line.separator") + "<qalab version=\""

             + XML_VERSION + "\">" + "   <summary/>" + "</qalab>";

     /** current XML version * */

     private String currentXmlVersion = null;

     /** the compiled stats. */

     private Document compiledStats = null;

     /** given implementation for the logger. * */

     private TaskLogger taskLogger = null;

     /** if true, no debug information is logged. * */

     private boolean quiet = true;

     /** the merged properties file. */

     private File outputFile = null;

     /** the action for same type and timestamp replace (default)| new. */

     private String action = "replace";

     /** timestamp to use. */

     private String timestampToUse = null;

     /** type of stats we are interested in. */

     private String typeToUse = null;

     /**

      * For instance for the XML Exporter.

      * <ul>

      * <li>qalab.outputfile = the output file name and path.</li>

      * <li>qalab.merge.output.classname = alternatively, the XML could be a

      * resource for this class</li>

      * <li>qalab.merge.output.resourcename = the resource name for the

      * qalab.merge.output.classname given</li>

      * <li>qalab.merge.timestamp = the timestamp YYYY-MM-dd HH:mm:ss</li>

      * <li>qalab.merge.type = the type of statistics being merged. (eg

      * checkstyle,findbugs,simian, pmd)</li>

      * <li>qalab.merge.action = the action to take in case of clash

      * type/timetstamp</li>

      * </ul>

      * 

      * @param properties

      *            the properties.

      * @see net.objectlab.qalab.interfaces.

      *      QALabExporter#configure(java.util.Properties)

      */

     public final void configure(final Properties properties) {

         InputStream stream = null;

         try {

             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

             factory.setValidating(false);

             stream = parseOriginalDocument(properties, factory);

             validateXmlVersion(compiledStats);

             if (!quiet) {

                 getTaskLogger().log("Parsed Statistics.");

             }

             loadActionAndStamp(properties);

             if ("replace".equals(action)) {

                 clearAll(timestampToUse, typeToUse);

                 if (!quiet) {

                     getTaskLogger().log("Finished clearing due to " + action);

                 }

             }

         } catch (IOException e) {

             throw new BuildException("Cannot create file ", e);

         } catch (SAXException e) {

             throw new BuildException("Cannot parse file ", e);

         } catch (ClassNotFoundException e) {

             throw new BuildException("Cannot find class ", e);

         } catch (ParserConfigurationException e) {

             throw new BuildException("Issue with ParserConfiguration ", e);

         } finally {

             if (stream != null) {

                 try {

                     stream.close();

                 } catch (IOException e) {

                     throw new BuildException("Cannot close streams", e);

                 }

             }

             if (!quiet) {

                 getTaskLogger().log("Finished Configuring XML streams.");

             }

         }

     }

     /**

      * @param properties

      */

     private void loadActionAndStamp(final Properties properties) {

         final String actionToUse = properties.getProperty("qalab.merge.action");

         if (actionToUse != null) {

             action = actionToUse.toLowerCase(Locale.ENGLISH);

         }

         if (!quiet) {

             getTaskLogger().log("ACTION: " + action);

         }

         // now check the timeStamp

         timestampToUse = properties.getProperty("qalab.merge.output.timestamp");

         if (!quiet) {

             getTaskLogger().log("Timestamp to use:" + timestampToUse);

         }

         typeToUse = properties.getProperty("qalab.merge.type");

     }

     /**

      * @param properties

      * @param factory

      * @return

      * @throws IOException

      * @throws FileNotFoundException

      * @throws ClassNotFoundException

      * @throws SAXException

      * @throws ParserConfigurationException

      */

     private InputStream parseOriginalDocument(final Properties properties, DocumentBuilderFactory factory) throws IOException,

             ClassNotFoundException, SAXException, ParserConfigurationException {

         InputStream stream;

         final String file = properties.getProperty("qalab.merge.output.file");

         if (file != null) {

             outputFile = new File(file);

             if (!quiet) {

                 getTaskLogger().log("Parsing " + outputFile);

             }

             if (!outputFile.exists()) {

                 // create the new file.

                 if (outputFile.createNewFile()) {

                     FileWriter stringOut = null;

                     try {

                         stringOut = new FileWriter(outputFile);

                         stringOut.write(EMPTY_FILE);

                         stringOut.flush();

                     } finally {

                         if (stringOut != null) {

                             stringOut.close();

                         }

                     }

                 } else {

                     throw new BuildException("Cannot create file " + outputFile.getAbsolutePath());

                 }

             }

             if (!quiet) {

                 getTaskLogger().log("Output file: " + outputFile.getAbsolutePath());

             }

             stream = new FileInputStream(outputFile);

         } else {

             final String resourceName = properties.getProperty("qalab.merge.output.resourcename");

             final String className = properties.getProperty("qalab.merge.output.classname");

             if (!quiet) {

                 getTaskLogger().log("Using Stream: " + resourceName + " for " + className);

             }

             stream = Class.forName(className).getResourceAsStream(resourceName);

         }

         // Create the builder and parse the file

         compiledStats = factory.newDocumentBuilder().parse(new InputSource(stream));

         return stream;

     }

     private void validateXmlVersion(Document doc) {

         Element qalab = getElement(doc.getElementsByTagName("qalab"));

         if (qalab != null) {

             currentXmlVersion = qalab.getAttribute("version");

             if (currentXmlVersion == null || !currentXmlVersion.equals(XML_VERSION)) {

                 getTaskLogger().log("Inadequate DTD, must change it to " + XML_VERSION);

                 qalab.setAttribute("version", XML_VERSION);

                 // now handle the change... from null or whatever to

                 // XML_VERSION.

                 changeXmlToDtdV11(qalab);

             }

         }

     }

     /**

      * @param qalab

      */

     private void changeXmlToDtdV11(Element qalab) {

         NodeList list = qalab.getChildNodes();

         for (int i = 0; i < list.getLength(); i++) {

             Node childNode = list.item(i);

             if (childNode.getNodeType() == Node.ELEMENT_NODE) {

                 if (QALabTags.FILE_TAG.equals(childNode.getNodeName())) {

                     Element fileNode = (Element) list.item(i);

                     String id = fileNode.getAttribute(QALabTags.ID_ATTRIBUTE);

                     fileNode.setAttribute(QALabTags.ID_ATTRIBUTE, id.replace('/', '_'));

                     fileNode.setAttribute(QALabTags.PATH_ATTRIBUTE, id);

                     // now in the results, check the timestamp

                     NodeList results = fileNode.getChildNodes();

                     for (int u = 0; u < results.getLength(); u++) {

                         Node resultNode = results.item(u);

                         if (resultNode.getNodeType() == Node.ELEMENT_NODE

                                 && QALabTags.RESULT_TAG.equals(resultNode.getNodeName())) {

                             Element resultElement = (Element) resultNode;

                             String timestamp = resultElement.getAttribute(QALabTags.DATE_ATTRIBUTE);

                             dropMidnight(resultElement, timestamp);

                         }

                     }

                 } else if (QALabTags.SUMMARY_TAG.equals(childNode.getNodeName())) {

                     Element summaryNode = (Element) list.item(i);

                     // now in the results, check the timestamp

                     NodeList results = summaryNode.getChildNodes();

                     for (int u = 0; u < results.getLength(); u++) {

                         Node resultNode = results.item(u);

                         if (resultNode.getNodeType() == Node.ELEMENT_NODE

                                 && QALabTags.SUMMARY_RESULT_TAG.equals(resultNode.getNodeName())) {

                             Element resultElement = (Element) resultNode;

                             String timestamp = resultElement.getAttribute(QALabTags.DATE_ATTRIBUTE);

                             dropMidnight(resultElement, timestamp);

                         }

                     }

                 }

             }

         }

     }

     /**

      * Remove the 00:00:00 from timestamp.

      * 

      * @param resultElement

      * @param timestamp

      */

     private void dropMidnight(Element resultElement, String timestamp) {

         final int indexOf = timestamp.indexOf(" 00:00:00");

         if (indexOf > 0) {

             resultElement.setAttribute(QALabTags.DATE_ATTRIBUTE, timestamp.substring(0, indexOf));

         }

     }

     /**

      * Add summary details for this merger of statistics for this type.

      * 

      * @param violationCount

      *            total number of violations for this type

      * @param fileCount

      *            total number of files affected by this type.

      */

     public final void addSummary(final int violationCount, final int fileCount) {

         NodeList list = compiledStats.getElementsByTagName(QALabTags.SUMMARY_TAG);

         for (int i = 0; i < list.getLength(); i++) {

             Node childNode = list.item(i);

             if (childNode.getNodeType() == Node.ELEMENT_NODE) {

                 Element summary = (Element) childNode;

                 Element foundSummaryResult = summary.getOwnerDocument().createElement(QALabTags.SUMMARY_RESULT_TAG);

                 foundSummaryResult.setAttribute(QALabTags.TYPE_ATTRIBUTE, typeToUse);

                 foundSummaryResult.setAttribute(QALabTags.FILECOUNT_ATTRIBUTE, "" + fileCount);

                 foundSummaryResult.setAttribute(QALabTags.STATVALUE_ATTRIBUTE, "" + violationCount);

                 foundSummaryResult.setAttribute(QALabTags.DATE_ATTRIBUTE, timestampToUse);

                 summary.appendChild(foundSummaryResult);

                 if (!isQuiet()) {

                     getTaskLogger().log("Summary:" + typeToUse + " file:" + fileCount + " issues:" + violationCount);

                 }

                 break;

             }

         }

     }

     /**

      * Add a result entry for a given file name and type.

      * 

      * @param violationCount

      *            total number of violations for this type and file.

      * @param fileName

      *            file name

      * @see net.objectlab.qalab.interfaces.QALabExporter#addFileResult(

      *      java.util.Date, int, java.lang.String, java.lang.String)

      */

     public final void addFileResult(final int violationCount, final String fileName) {

         String id = fileName.replace('/', '_');

         Element fileElement = compiledStats.getElementById(id);

         if (!isQuiet()) {

             taskLogger.log("* addNewResults for [" + fileName + "] Element:" + id);

         }

         if (fileElement == null) {

             if (!isQuiet()) {

                 taskLogger.log("Create file new ENTRY......");

             }

             fileElement = compiledStats.createElement(QALabTags.FILE_TAG);

             fileElement.setAttribute(QALabTags.ID_ATTRIBUTE, id);

             fileElement.setAttribute(QALabTags.PATH_ATTRIBUTE, fileName);

             compiledStats.getDocumentElement().appendChild(fileElement);

         }

         Element newResult = compiledStats.createElement(QALabTags.RESULT_TAG);

         newResult.setAttribute(QALabTags.TYPE_ATTRIBUTE, typeToUse);

         newResult.setAttribute(QALabTags.STATVALUE_ATTRIBUTE, "" + violationCount);

         newResult.setAttribute(QALabTags.DATE_ATTRIBUTE, timestampToUse);

         fileElement.appendChild(newResult);

     }

     /**

      * Find the element in the children that has the same timestamp and type.

      * 

      * @param startingElement

      *            the start element in the DOM

      * @param timestampStr

      *            the timestamp

      * @param type

      *            the type we are looking for.

      * @return Element or null if not found

      */

     private Element findSameTypeAndTimestamp(final Element startingElement, final String timestampStr, final String type) {

         Element newResult = null;

         NodeList fileResults = startingElement.getChildNodes();

         if ("replace".equals(action)) {

             for (int u = 0; u < fileResults.getLength() && newResult == null; u++) {

                 Node resultNode = fileResults.item(u);

                 if (resultNode.getNodeType() == Node.ELEMENT_NODE) {

                     final String stamp = Util.getAttributeValue(resultNode.getAttributes(), "date", isQuiet(), getTaskLogger());

                     final String existingType = Util.getAttributeValue(resultNode.getAttributes(), "type", isQuiet(),

                             getTaskLogger());

                     if (timestampStr.equals(stamp) && type.equals(existingType)) {

                         newResult = (Element) resultNode;

                     }

                 }

             }

         }

         return newResult;

     }

     /**

      * Save the stats (called when the parsing of input statistics is

      * completed).

      * 

      * @see net.objectlab.qalab.interfaces.QALabExporter#save()

      */

     public final void save() throws IOException {

         OutputFormat format = new OutputFormat(compiledStats, "UTF-8", true);

         FileWriter stringOut = new FileWriter(outputFile);

         if (!XML_VERSION.equals(currentXmlVersion)) {

             // replace DTD!

             StringWriter sw = new StringWriter();

             XMLSerializer serial = new XMLSerializer(sw, format);

             serial.asDOMSerializer(); // As a DOM Serializer

             serial.serialize(compiledStats);

             sw.flush();

             sw.close();

             StringBuffer newXml = new StringBuffer(sw.getBuffer().substring(sw.getBuffer().indexOf("<qalab")));

             newXml.insert(0, DTD_DEFINITION);

             stringOut.write(newXml.toString());

         } else {

             XMLSerializer serial = new XMLSerializer(stringOut, format);

             serial.asDOMSerializer(); // As a DOM Serializer

             serial.serialize(compiledStats);

         }

         stringOut.flush();

         stringOut.close();

     }

     /**

      * @return logger to use if not quiet.

      */

     protected final TaskLogger getTaskLogger() {

         return taskLogger;

     }

     /**

      * set the task logger, ie mechanism to log issues & debug info.

      * 

      * @param task

      *            the logger to use

      */

     public final void setTaskLogger(final TaskLogger task) {

         taskLogger = task;

     }

     /**

      * @return true means that no debug info is logged.

      */

     public final boolean isQuiet() {

         return quiet;

     }

     /**

      * @param noLog

      *            true if no log required.

      */

     public final void setQuiet(final boolean noLog) {

         this.quiet = noLog;

     }

     /**

      * @return the compiled document.

      */

     public final Document getDocument() {

         return compiledStats;

     }

     /**

      * get rid of the element with same timestamp and type.

      * 

      * @param timestampStr

      *            the timestamp to eliminate

      * @param type

      *            the type to eliminate

      */

     private void clearAll(final String timestampStr, final String type) {

         // first get rid of the summary

         NodeList list = compiledStats.getElementsByTagName(QALabTags.SUMMARY_TAG);

         clearChildren(list, timestampStr, type);

         // first get rid of the files

         NodeList listFiles = compiledStats.getElementsByTagName(QALabTags.FILE_TAG);

         clearChildren(listFiles, timestampStr, type);

     }

     /**

      * get rid of the element with same timestamp and type.

      * 

      * @param list

      *            list of nodes that may contain items with same timestamp and

      *            type.

      * @param timestampStr

      *            the timestamp to eliminate

      * @param type

      *            the type to eliminate

      */

     private void clearChildren(final NodeList list, final String timestampStr, final String type) {

         for (int i = 0; i < list.getLength(); i++) {

             Node childNode = list.item(i);

             if (childNode.getNodeType() == Node.ELEMENT_NODE) {

                 Element summary = (Element) childNode;

                 Element foundSummaryResult = findSameTypeAndTimestamp(summary, timestampStr, type);

                 // get rid of it!

                 if (foundSummaryResult != null) {

                     if (!isQuiet()) {

                         getTaskLogger()

                                 .log("Removing element due to same type and timestamp " + foundSummaryResult.getNodeName());

                     }

                     childNode.removeChild(foundSummaryResult);

                 }

             }

         }

     }

     private Element getElement(NodeList list) {

         for (int i = 0; i < list.getLength(); i++) {

             Node childNode = list.item(i);

             if (childNode.getNodeType() == Node.ELEMENT_NODE) {

                 return (Element) childNode;

             }

         }

         return null;

     }

 }

 /*

  *                   ObjectLab is sponsoring QALab

  * 

  * Based in London, we are world leaders in the design and development 

  * of bespoke applications for the securities financing markets.

  * 

  * <a href="http://www.objectlab.co.uk/open">Click here to learn more about us</a>

  *           ___  _     _           _   _          _

  *          / _ \| |__ (_) ___  ___| |_| |    __ _| |__

  *         | | | | '_ \| |/ _ \/ __| __| |   / _` | '_ \

  *         | |_| | |_) | |  __/ (__| |_| |__| (_| | |_) |

  *          \___/|_.__// |\___|\___|\__|_____\__,_|_.__/

  *                   |__/

  *

  *                     www.ObjectLab.co.uk

  */