xmerge/workben/XmlDiff.java

   1 /************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 import java.io.FileWriter;
  29 import java.io.InputStream;
  30 import java.io.FileInputStream;
  31 import java.io.BufferedInputStream;
  32 import java.io.BufferedWriter;
  33 import java.io.IOException;
  34 import java.io.FileNotFoundException;
  35 import java.io.OutputStream;
  36 import java.io.OutputStreamWriter;
  37 import java.io.Writer;
  38 import java.io.PrintWriter;
  39 import java.util.Vector;
  40 import java.util.Properties;
  41
  42 import javax.xml.parsers.DocumentBuilderFactory;
  43 import javax.xml.parsers.DocumentBuilder;
  44 import javax.xml.parsers.ParserConfigurationException;
  45
  46 import org.w3c.dom.Node;
  47 import org.w3c.dom.Document;
  48 import org.w3c.dom.NodeList;
  49 import org.xml.sax.SAXException;
  50 import org.xml.sax.SAXParseException;
  51 /**
  52  *  This class will diff 2 Xml files.
  53  *
  54  *  @author   Stephen Mak
  55  */
  56
  57 public final class XmlDiff {
  58
  59     private static final String PROPSFILE = "XmlDiff.properties";
  60     private static final String FILE1 = "XmlDiff.file1";
  61     private static final String FILE2 = "XmlDiff.file2";
  62     private static final String OUTPUT= "XmlDiff.output";
  63     private static final String IGNORE_TAGS= "XmlDiff.tags";
  64
  65     private Properties props_ = null;
  66     private static PrintWriter writer_ = null;
  67     private String[] tags_ = null;
  68     private String file1_ = null;
  69     private String file2_ = null;
  70
  71     /**
  72      *  Constructor.  Load the properties file.
  73      */
  74
  75     public XmlDiff() throws IOException {
  76
  77         Class c = this.getClass();
  78         InputStream is = c.getResourceAsStream(PROPSFILE);
  79         BufferedInputStream bis = new BufferedInputStream(is);
  80         props_ = new Properties();
  81         props_.load(bis);
  82         bis.close();
  83
  84         String file1 = props_.getProperty(FILE1, "");
  85         String file2 = props_.getProperty(FILE2, "");
  86         String tagsString = props_.getProperty(IGNORE_TAGS, "");
  87         String output = props_.getProperty("debug.output", "System.out");
  88         setOutput(output);
  89         tags_ = parseTags(tagsString);
  90     }
  91
  92     /**
  93      * diff 2 xml, but overwrite the property file's file1/2 setting with
  94      * the input argument
  95      */
  96     public boolean diff(String file1, String file2)  throws IOException {
  97         file1_ = file1;
  98         file2_ = file2;
  99         return diff();
 100     }
 101
 102     public boolean diff() throws IOException {
 103
 104         boolean result = false;
 105
 106         writer_.println("parsing "+ file1_ + "...");
 107         // parse the Xml file
 108         Document doc1 = parseXml(file1_);
 109
 110         writer_.println("parsing "+ file1_ + "...");
 111         Document doc2 = parseXml(file2_);
 112
 113         if (doc1 != null && doc2 != null) {
 114           writer_.println("diffing "+ file1_ + " & " + file2_ + "...");
 115           result = compareNode(doc1, doc2);
 116         }
 117         return result;
 118     }
 119
 120     private void diffLog(String errMsg, Node node1, Node node2) {
 121
 122         String node1Str = "";
 123         String node2Str = "";
 124
 125         if (node1 != null) {
 126             node1Str = "[Type]:" + nodeInfo(node1) +
 127                        " [Name]:" + node1.getNodeName();
 128             if (node1.getNodeValue() != null)
 129                 node1Str += " [Value]:" + node1.getNodeValue();
 130         }
 131
 132         if (node2 != null) {
 133             node2Str = "[Type]:" + nodeInfo(node2) +
 134                        " [Name]:" + node2.getNodeName();
 135             if (node2.getNodeValue() != null)
 136                 node2Str += " [Value]:" + node2.getNodeValue();
 137         }
 138
 139         writer_.println(errMsg);
 140         writer_.println("  Node1 - " + node1Str);
 141         writer_.println("  Node2 - " + node2Str);
 142     }
 143
 144     private String nodeInfo(Node node) {
 145
 146         String str = null;
 147         switch (node.getNodeType()) {
 148
 149             case Node.ELEMENT_NODE:
 150                 str = "ELEMENT";
 151                 break;
 152             case Node.ATTRIBUTE_NODE:
 153                 str = "ATTRIBUTE";
 154                 break;
 155             case Node.TEXT_NODE:
 156                 str = "TEXT";
 157                 break;
 158             case Node.CDATA_SECTION_NODE:
 159                 str = "CDATA_SECTION";
 160                 break;
 161             case Node.ENTITY_REFERENCE_NODE:
 162                 str = "ENTITY_REFERENCE";
 163                 break;
 164             case Node.ENTITY_NODE:
 165                 str = "ENTITY";
 166                 break;
 167             case Node.PROCESSING_INSTRUCTION_NODE:
 168                 str = "PROCESSING_INSTRUCTION";
 169                 break;
 170             case Node.COMMENT_NODE:
 171                 str = "COMMENT";
 172                 break;
 173             case Node.DOCUMENT_NODE:
 174                 str = "DOCUMENT";
 175                 break;
 176             case Node.DOCUMENT_TYPE_NODE:
 177                 str = "DOCUMENT_TYPE";
 178                 break;
 179             case Node.DOCUMENT_FRAGMENT_NODE:
 180                 str = "DOCUMENT_FRAGMENT";
 181                 break;
 182             case Node.NOTATION_NODE:
 183                 str = "NOTATION";
 184                 break;
 185         }
 186         return str;
 187     }
 188
 189     private boolean ignoreTag(String nodeName) {
 190
 191
 192         if (tags_ != null) {
 193             for (int i = 0; i < tags_.length; i++) {
 194                 if (tags_[i].equals(nodeName))
 195                     return true;
 196             }
 197         }
 198         return false;
 199     }
 200
 201     // for future use if we want to compare attributes
 202     private boolean attributesEqual(Node node1, Node node2) {
 203         return true;
 204     }
 205
 206     private boolean compareNode(Node node1, Node node2) {
 207         boolean equal = false;
 208
 209         while (true) {
 210
 211             if (node1 == null && node2 == null) {
 212                 equal = true;
 213                 break;
 214             } else if (node1 == null || node2 == null) {
 215                 diffLog("DIFF: one of the node is null", node1, node2);
 216                 break;
 217             }
 218
 219             if (node1.getNodeType() != node2.getNodeType()) {
 220                 diffLog("DIFF: nodetype is different", node1, node2);
 221                 break;
 222             }
 223
 224             if (node1.getNodeName() == null && node2.getNodeName() == null) {
 225                 // empty
 226             } else if (node1.getNodeName() == null ||
 227                        node2.getNodeName() == null) {
 228                 diffLog("DIFF: one of the nodeName is null", node1, node2);
 229                 break;
 230             } else if (!node1.getNodeName().equals(node2.getNodeName())) {
 231                 diffLog("DIFF: nodeName is different", node1, node2);
 232                 break;
 233             }
 234
 235             if (ignoreTag(node1.getNodeName())) {
 236                 diffLog("DIFF: Some tag(s) is ignored", node1, node2);
 237                 equal = true;
 238                 break;
 239             }
 240
 241             if (node1.getNodeValue() == null && node2.getNodeValue() == null) {
 242                 // empty
 243             } else if (node1.getNodeValue() == null ||
 244                        node2.getNodeValue() == null) {
 245                 diffLog("DIFF: one of the nodevalue is null", node1, node2);
 246                 break;
 247             } else if (!node1.getNodeValue().equals(node2.getNodeValue())) {
 248                 diffLog("DIFF: nodeValue is different", node1, node2);
 249                 break;
 250             }
 251
 252             // try to compare attributes if necessary
 253             if (!attributesEqual(node1, node2))
 254                 break;
 255
 256             NodeList node1Children = node1.getChildNodes();
 257             NodeList node2Children = node2.getChildNodes();
 258
 259             // number of children have to be the same
 260             if (node1Children == null && node2Children == null) {
 261                 equal = true;
 262                 break;
 263             }
 264
 265             if (node1Children == null || node2Children == null) {
 266                 diffLog("DIFF: one node's children is null", node1, node2);
 267                 break;
 268             }
 269
 270             if (node1Children.getLength() != node2Children.getLength())  {
 271                 diffLog("DIFF: num of children is different", node1, node2);
 272                 break;
 273             }
 274
 275             // compare all the childrens
 276             equal = true;
 277
 278             for (int i = 0; i < node1Children.getLength(); i++) {
 279                 if (!compareNode(node1Children.item(i),
 280                                  node2Children.item(i))) {
 281                     equal = false;
 282                     break;
 283                 }
 284             }
 285             break;
 286         }
 287
 288         return equal;
 289     }
 290
 291     private Document parseXml (String filename) throws IOException {
 292
 293         Document w3cDocument = null;
 294
 295         FileInputStream fis;
 296
 297         try {
 298             fis = new FileInputStream(filename);
 299         } catch (FileNotFoundException ex) {
 300             ex.printStackTrace(writer_);
 301             writer_.println(ex.getMessage());
 302             return w3cDocument;
 303         }
 304
 305         /** factory for DocumentBuilder objects */
 306         DocumentBuilderFactory factory = null;
 307         factory = DocumentBuilderFactory.newInstance();
 308         factory.setNamespaceAware(true);
 309         factory.setValidating(false);
 310
 311         /** DocumentBuilder object */
 312         DocumentBuilder builder = null;
 313
 314         try {
 315             builder = factory.newDocumentBuilder();
 316         } catch (ParserConfigurationException ex) {
 317             ex.printStackTrace(writer_);
 318             writer_.println(ex.getMessage());
 319             return null;
 320         }
 321
 322
 323         builder.setErrorHandler(
 324             new org.xml.sax.ErrorHandler() {
 325                 // ignore fatal errors (an exception is guaranteed)
 326                 public void fatalError(SAXParseException e)
 327                     throws SAXException {
 328                     throw e;
 329                 }
 330
 331                 public void error(SAXParseException e)
 332                     throws SAXParseException {
 333                     // make sure validation error is thrown.
 334                     throw e;
 335                 }
 336
 337                 public void warning(SAXParseException e)
 338                     throws SAXParseException {
 339                 }
 340             }
 341         );
 342
 343         try {
 344             w3cDocument = builder.parse(fis);
 345             w3cDocument.getDocumentElement().normalize();
 346         } catch (SAXException ex) {
 347             ex.printStackTrace(writer_);
 348             writer_.println(ex.getMessage());
 349             return w3cDocument;
 350         }
 351
 352         return w3cDocument;
 353     }
 354
 355     private String [] parseTags(String tagsString) {
 356         Vector tagsVector = new Vector();
 357         if (tagsString.length() == 0)
 358             return null;
 359
 360         int start = 0;
 361         int end = 0;
 362         // break the tag string into a vector of strings by words
 363         for (end = tagsString.indexOf(" ", start);
 364              end != -1 ;
 365              start = end + 1, end = tagsString.indexOf(" ", start)) {
 366             tagsVector.add(tagsString.substring(start,end));
 367         }
 368
 369         tagsVector.add(tagsString.substring(start,tagsString.length()));
 370
 371         // convert the vector to array
 372         String[] tags= new String[tagsVector.size()];
 373         tagsVector.copyInto(tags);
 374
 375         return tags;
 376     }
 377
 378
 379     /**
 380      *  Set the output to the specified argument.
 381      *  This method is only used internally to prevent
 382      *  invalid string parameter.
 383      *
 384      *  @param   str   output specifier
 385      */
 386     private static void setOutput(String str) {
 387
 388         if (writer_ == null) {
 389
 390             if (str.equals("System.out")) {
 391
 392                 setOutput(System.out);
 393
 394             } else if (str.equals("System.err")) {
 395
 396                 setOutput(System.err);
 397
 398             } else {
 399
 400                 try {
 401
 402                     setOutput(new FileWriter(str));
 403
 404                 } catch (IOException e) {
 405
 406                     e.printStackTrace(System.err);
 407                 }
 408             }
 409         }
 410     }
 411
 412     /**
 413      *  Set the output to an OutputStream object.
 414      *
 415      *  @param   stream   OutputStream object
 416      */
 417
 418     private static void setOutput(OutputStream stream) {
 419
 420         setOutput(new OutputStreamWriter(stream));
 421     }
 422
 423     /**
 424      *  Set the Writer object to manage the output.
 425      *
 426      *  @param   w   Writer object to write out
 427      */
 428
 429     private static void setOutput(Writer w) {
 430
 431         if (writer_ != null) {
 432
 433             writer_.close();
 434         }
 435
 436         writer_ = new PrintWriter(new BufferedWriter(w), true);
 437     }
 438
 439     public static void main(String args[]) throws IOException {
 440
 441         if (args.length != 0 && args.length != 2) {
 442             System.out.println("Usage: XmlDiff [<file1> <file2>].");
 443             return;
 444         }
 445
 446         XmlDiff xmldiff = new XmlDiff();
 447
 448         boolean same = false;
 449         if (args.length == 2) {
 450             same = xmldiff.diff(args[0], args[1]);
 451         } else {
 452             same = xmldiff.diff();
 453         }
 454
 455         System.out.println("Diff result: " + same);
 456     }
 457 }
 458