TextModificationsXMLUnitProvider.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Lukáš Kubík kubiklukas@seznam.cz
 * File: TextModificationsXMLUnitProvider.java
 * Description: Class for providing TextModification differences between two versions of document
 */

/**
 * @file TextModificationsXMLUnitProvider.java
 *
 * @brief TextModification provider
 */

/**
 * @package cz.vutbr.fit.knot.annotations.textModifications
 *
 * @brief Classes for providing TextModification differences between two versions of document
 */
package cz.vutbr.fit.knot.annotations.textModifications;

import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.TextModification;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.XPathHelper;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPathExpressionException;
import nu.validator.htmlparser.dom.HtmlDocumentBuilder;
import org.custommonkey.xmlunit.DetailedDiff;
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.Difference;
import org.custommonkey.xmlunit.NodeDetail;
import org.custommonkey.xmlunit.XMLUnit;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * Class for providing TextModification differences between two versions of document
 *
 * @brief TextModification provider
 * @author xkubik22
 */
public class TextModificationsXMLUnitProvider {
  
  
  /**
   * Provides the TextModifications
   * 
   * @param oldVersion Old version of the document
   * @param newVersion New version of the document
   * @param highestProtocol Highest available protocol version
   * @return New TextModifications
   * @throws ParserConfigurationException
   * @throws SAXException
   * @throws IOException
   */
  public static ArrayList<TextModification> getTextModifications(String oldVersion, String newVersion,
          int highestProtocol) throws ParserConfigurationException, SAXException, IOException{
    //parse strings into the Document entities
    HtmlDocumentBuilder htmlDocumentBuilder = new HtmlDocumentBuilder();
    
    InputSource inputSourceOld = new InputSource(new StringReader(oldVersion));
    InputSource inputSourceNew = new InputSource(new StringReader(newVersion));
    
    Document oldDom = htmlDocumentBuilder.parse(inputSourceOld);
    Document newDom = htmlDocumentBuilder.parse(inputSourceNew);
    
    //call the real text modification provider
    return getTextModifications(oldDom, newDom, highestProtocol);
  }
  
  /**
   * Provides the TextModifications
   * 
   * @param oldVersion Old version of the document
   * @param newVersion New version of the document
   * @param highestProtocol Highest available protocol version
   * @return New TextModifications
   * @throws SAXException
   * @throws IOException 
   */
  public static ArrayList<TextModification> getTextModifications(Document oldVersion, Document newVersion,
          int highestProtocol) throws SAXException, IOException{
    //This configuration will ignore attribute order!    
    XMLUnit.setIgnoreAttributeOrder(false);
    //diff documents
    Diff diff = new Diff(oldVersion, newVersion);
    DetailedDiff myDiff = new DetailedDiff(diff);
    List allDifferences = myDiff.getAllDifferences();
    // initialize variables
    LinkedHashMap<String, TextModification> pathModMap = new LinkedHashMap<String, TextModification>();
    // Failsafe variable - if an unprogrammed description or an unprogrammed behavior appears then whole body will be replaced
    boolean unknownDif = false;
    // loop throught the differences
    for (int i=0; i<allDifferences.size(); i++) {
      Difference difference = (Difference) allDifferences.get(i);
      // old document node detail
      NodeDetail controlNode = difference.getControlNodeDetail();
      // difference description
      String desc = difference.getDescription();
      // new document node detail
      NodeDetail testNode = difference.getTestNodeDetail();
      // change a text of some node
      if(desc.equalsIgnoreCase("text value")){
        // only nodes with same xpaths are changed, otherwise it's some odd behavior of the library
        if(controlNode.getXpathLocation() != null && controlNode.getXpathLocation().equals(testNode.getXpathLocation())){
          replaceNode(pathModMap, testNode);
        }
      }
      // add/remove a node
      // Comparing 2 nodes and one holds more childnodes than can be
      // matched against child nodes of the other.
      else if(desc.equalsIgnoreCase("presence of child node")){
        if(testNode.getXpathLocation() == null){
          removeNode(pathModMap, controlNode, highestProtocol, newVersion);
          continue;
        }
        Node failSafeNode = null;
        try {
          failSafeNode = XPathHelper.getNode(oldVersion, testNode.getXpathLocation());
        } catch (XPathExpressionException ex) {
          unknownDif = true;
          break;
        }
        // if the node for add already exists in the old document then don't add - it's some odd behavior of the library
        if(failSafeNode == null){          
          if(!addNode(highestProtocol, pathModMap, testNode, oldVersion)){
            unknownDif = true;
          }
        } // failsafe
      }
      //add/remove a node
      // Comparing 2 nodes with children whose nodes are in different sequence
      else if(desc.equalsIgnoreCase("sequence of child nodes")){
        if(controlNode.getXpathLocation() != null && controlNode.getXpathLocation().equals(testNode.getXpathLocation())){
          replaceNode(pathModMap, testNode);
        }
        else{
          if(controlNode.getXpathLocation() != null){
            if(getNodeIfExists(newVersion, controlNode.getNode()) == null){
              removeNode(pathModMap, controlNode, highestProtocol, newVersion);
              continue; //only remove
            }
            else{
              replaceNode(pathModMap, controlNode);
            }
          }
          if(testNode.getXpathLocation() != null){
            if(getNodeIfExists(oldVersion, testNode.getNode()) == null){
              if(!addNode(highestProtocol, pathModMap, testNode, oldVersion)){
                unknownDif = true;
                break;
              }
            }
            else{
              replaceNode(pathModMap, testNode);
            }
          }
        }
      }
      // redundant info
      else if(desc.equalsIgnoreCase("number of child nodes")){
        continue;
      }
      // replace element
      else if(desc.equalsIgnoreCase("number of element attributes") || 
              desc.equalsIgnoreCase("attribute name") ||
              desc.equalsIgnoreCase("attribute value") ||
              desc.equalsIgnoreCase("attribute value explicitly specified") ||
              desc.equalsIgnoreCase("sequence of attributes") ||
              desc.equalsIgnoreCase("element tag name") ||// Comparing 2 elements with different tag names
              desc.equalsIgnoreCase("node type") ||/** Comparing 2 nodes with different node types */
              desc.equalsIgnoreCase("presence of child nodes to be"))// Comparing 2 nodes but only one has any children
      {
        if(controlNode.getXpathLocation() != null && controlNode.getXpathLocation().equals(testNode.getXpathLocation())){
          replaceNode(pathModMap, testNode);
        }
        else{
          if(controlNode.getXpathLocation() != null){
            if(getNodeIfExists(newVersion, controlNode.getNode()) == null){
              removeNode(pathModMap, controlNode, highestProtocol, newVersion); 
            }
            else{
              replaceNode(pathModMap, controlNode);
            }
          }
          if(testNode.getXpathLocation() != null){
            if(getNodeIfExists(oldVersion, testNode.getNode()) == null){
              if(!addNode(highestProtocol, pathModMap, testNode, oldVersion)){
                unknownDif = true;
                break;
              }
            }
            else{
              replaceNode(pathModMap, testNode);
            }
          }
        }
      }
      // unknown type of the difference
      else{
        unknownDif = true;
        break;
      }
    }
    // unknown type of difference appeared in the update -> update whole body
    if(unknownDif){
      ArrayList<TextModification> tmsUnit = new ArrayList<TextModification>();
      tmsUnit.add(exchangeWholeBody(newVersion));
      return tmsUnit;
    }
    ArrayList<TextModification> tmsUnit = new ArrayList<TextModification>(pathModMap.values());
    return tmsUnit;
  }
  
  /**
   * Returns a text modification on whole body element
   * 
   * @param newVersion New version of the document
   * @return text modification on whole body element
   */
  private static TextModification exchangeWholeBody(Document newVersion){
    Node node = newVersion.getFirstChild();
    while (node == null || !node.getNodeName().equalsIgnoreCase("html")) {
      return null;
    }
    String replace = "";
    replace += nodeToString(node);
    return new TextModification("/", null, null, replace);
  }

  /**
   * Converts node into string form
   *
   * @param root Node to convert
   * @return Returns node in string form
   *
   */
  public static String nodeToString(Node root) {

    String rootName = root.getNodeName().toLowerCase();
    StringBuilder sb = new StringBuilder();

    if (root.getNodeType() != Node.TEXT_NODE) {
      if (root.getNodeName().equalsIgnoreCase("br")) {
        return "<br>";
      } else if (root.getNodeName().equalsIgnoreCase("hr")) {
        return "<hr>";
      }

      sb.append("<").append(rootName);
      sb.append(attributeToString(root.getAttributes()));
      sb.append(">");

      NodeList nl = root.getChildNodes();
      for (int i = 0; i < nl.getLength(); i++) {
        Node n = nl.item(i);
        if (n.getNodeType() == Node.TEXT_NODE) {
          sb.append(n.getNodeValue());
        } else {
          sb.append(nodeToString(n));
        }
      }
      sb.append("</").append(rootName).append(">");
    } else {
      sb.append(root.getNodeValue());
    }

    return sb.toString();
  }
  
  /**
   * Converts attribute map into string
   * 
   * @param attributes Attribute map for conversion
   * @return Attribute converted to string
   */
  public static String attributeToString(NamedNodeMap attributes){
    int attrLength = attributes.getLength();
    
    if(attrLength > 0){
      StringBuilder sb = new StringBuilder(" ");
      for(int i = 0; i < attrLength; i++){
        Node attr = attributes.item(i);
        sb.append(attr.getNodeName());
        sb.append("=\"");
        sb.append(attr.getNodeValue());
        if(i != attrLength-1){
          sb.append("\" ");
        }
        else{
          sb.append("\"");
        }
      }
      return sb.toString();
    }
    
    return "";
  }
  
  /**
   * Method that gets the last sibling of the node
   * 
   * @param node Node for sibling
   * @return Last sibling
   */
  private static Node lastSiblingNode(Node node){
    Node sibling = node;
    while(sibling.getNextSibling() != null){
      sibling = sibling.getNextSibling();
    }
    return sibling;
  }
  
  /**
   * Method that checks if there already exists a TextModification for 
   * some element or it's parent modification.
   * 
   * @param pathModMap Map of the created text modifications
   * @param XPath XPath of the element
   * @return true if exists otherwise false
   */
  private static boolean existsParentMod(LinkedHashMap<String, TextModification> pathModMap, String XPath){  
    Set<String> paths = pathModMap.keySet();
    Iterator<String> it = paths.iterator();
    while(it.hasNext()){
      String path = it.next();
      if(XPath.contains(path)){
        return true;
      }
    }
    return false;
  }
  
  /**
   * Method that removes all child modifications of some element
   * 
   * @param pathModMap Map of the created text modifications
   * @param XPath XPath of the element
   */
  private static void removeAllChildMods(LinkedHashMap<String, TextModification> pathModMap, String XPath){
    Iterator<Entry<String, TextModification>> setIt = pathModMap.entrySet().iterator();
    while(setIt.hasNext()){
      Entry<String, TextModification> entry = setIt.next();
      if(entry.getKey().contains(XPath)){
        setIt.remove();
      }
    }
  }
  
  /**
   * Method gets the first previous node of some node that exists in a version of the document
   * 
   * @param testedNode Node fot getting it's previous node
   * @param version Version of a document
   * @return Previous node or null
   */
  private static Node getFirstPreviousNodeExistingInDoc(Node testedNode, Document version){
    Node prevNode = testedNode.getPreviousSibling();
    Node evaluatedNode = null;
    while(prevNode != null && evaluatedNode == null){
      try {
        evaluatedNode = XPathHelper.getNode(version, XPathHelper.XPathStringOfNode(prevNode));
      } catch (XPathExpressionException ex) {
        prevNode = prevNode.getPreviousSibling();
        continue;
      }
      prevNode = prevNode.getPreviousSibling();
    }
    return evaluatedNode;
  }
  
  /**
   * Method that test if some node is not a text node and not a br or a hr element
   * 
   * @param testedNode Node for test
   * @return True if node is a text node or a br or a hr element. Otherwise false.
   */
  private static boolean isNodeNotTextAndNotBRHR(Node testedNode){
    if(testedNode.getNodeType() != Node.TEXT_NODE &&
            !testedNode.getNodeName().equalsIgnoreCase("br") &&
            !testedNode.getNodeName().equalsIgnoreCase("hr")){
      return true;
    }
    return false;
  }
  
  /**
   * Gets the parent element in the oldVersion
   * 
   * @param oldVersion Old version of the document
   * @param child Child node for getting the parent node
   * @return Parent node if exists or null
   */
  private static Node getParentIfExists(Document oldVersion, Node child){
    Node parent = child.getParentNode();

    if(parent!= null){
      String parentPath = XPathHelper.XPathStringOfNode(parent);
      Node evaluatedNode = null;
      try {
        evaluatedNode = XPathHelper.getNode(oldVersion, parentPath);
      } catch (XPathExpressionException ex) {
        return null;
      }
      return evaluatedNode;
    }
    
    return null;
  }
  
  /**
   * Gets the element in the version of the document
   * 
   * @param version A Version of the document
   * @param node node in the version
   * @return Node if exists or null
   */
  private static Node getNodeIfExists(Document version, Node node){

    String parentPath = XPathHelper.XPathStringOfNode(node);
    Node evaluatedNode = null;
    try {
      evaluatedNode = XPathHelper.getNode(version, parentPath);
    } catch (XPathExpressionException ex) {
      return null;
    }
    return evaluatedNode;
  }
  
  /**
   * Gets the element in the version of the document
   * 
   * @param version A version of the document
   * @param XPath XPath in the version
   * @return Node if exists or null
   */
  private static Node getNodeIfExists(Document version, String XPath){
    Node evaluatedNode = null;
    try {
      evaluatedNode = XPathHelper.getNode(version, XPath);
    } catch (XPathExpressionException ex) {
      return null;
    }
    return evaluatedNode;
  }
  
  /**
   * Creates a TextModification that adds a node
   * 
   * @param highestProtocol highest available protocol version
   * @param pathModMap Map of the created text modifications
   * @param addNodeDetail Node for add
   * @param oldVersion Old version of the document
   * @return True if success, otherwise false
   */
  private static boolean addNode(int highestProtocol, 
          LinkedHashMap<String,TextModification> pathModMap,
          NodeDetail addNodeDetail, Document oldVersion)
  {
    if(!existsParentMod(pathModMap, addNodeDetail.getXpathLocation())){
      Node addNode = addNodeDetail.getNode();
      boolean v2Success = false;
      //not inserting text or br or hr element
      boolean skipFirst = false;
      if(highestProtocol >= Constants.PROTOCOL_LOD_V2){
        skipFirst = true;
        Node previousNode = addNode.getPreviousSibling();
        boolean tryNextNode = false;
        //try insert after
        if(previousNode != null){
          String path = XPathHelper.XPathStringOfNode(previousNode);
          if(pathModMap.containsKey(path) || getNodeIfExists(oldVersion, previousNode) != null){
            String content = nodeToString(addNode);
            TextModification newMod = new TextModification(path, null, null, content, Constants.TEXT_MOD_INS_AFTER);
            //Attention: adding the path where it is going to be added! Not the path of the previous node!
            pathModMap.put(addNodeDetail.getXpathLocation(), newMod);
            v2Success = true;
          }
          else{
            tryNextNode = true;
          }
        }
        else{
          tryNextNode = true;
        }
        if(tryNextNode){
          Node nextNode = addNode.getNextSibling();
          //try insert before
          if(nextNode != null){
            String path = XPathHelper.XPathStringOfNode(nextNode);        
            if(pathModMap.containsKey(path) || getNodeIfExists(oldVersion, nextNode) != null){
              String content = nodeToString(addNode);
              TextModification newMod = new TextModification(path, null, null, content, Constants.TEXT_MOD_INS_BEFORE);
              //Attention: adding the path where it is going to be added! Not the path of the next node!
              pathModMap.put(addNodeDetail.getXpathLocation(), newMod);
              v2Success = true;
            }
          }
        }
      }
      //Old protocol - replace parent node or previous node
      if(!v2Success){

        //inserting text element or br or hr element
        if(!isNodeNotTextAndNotBRHR(addNode)){
          skipFirst = true;
        }
        Node firstPreviousNode = null;
        Node firstParentNode = null;   
        Node evaluatedNode = addNode;
        while(firstPreviousNode == null && firstParentNode == null){
          if(!skipFirst){
            firstPreviousNode = getFirstPreviousNodeExistingInDoc(evaluatedNode, oldVersion);
          }
          skipFirst = false;
          if(firstPreviousNode == null || !isNodeNotTextAndNotBRHR(firstPreviousNode)){
            firstParentNode = getParentIfExists(oldVersion, evaluatedNode);
            firstPreviousNode = null;
            if(firstParentNode == null){
              evaluatedNode = evaluatedNode.getParentNode();
              if(evaluatedNode == null){
                return false;
              }
            }
          }
        }
        if(firstPreviousNode != null){
          String firstPreviousNodePath = XPathHelper.XPathStringOfNode(firstPreviousNode);
          //try get already existing replace modification for the first previous node
          TextModification modForUpdate = pathModMap.get(firstPreviousNodePath);
          //append node for add to the existing replace modification
          if(modForUpdate != null){
            String content = modForUpdate.getNewContent();
            content += nodeToString(evaluatedNode);
            modForUpdate.setNewContent(content);
          }
          //create new replace modification
          else{
            String content = nodeToString(firstPreviousNode);
            content += nodeToString(evaluatedNode);
            TextModification newMod = new TextModification(firstPreviousNodePath, null, null, content);
            removeAllChildMods(pathModMap, firstPreviousNodePath);
            pathModMap.put(firstPreviousNodePath, newMod);
          }
        }
        else if(firstParentNode != null){
          String firstParentNodePath = XPathHelper.XPathStringOfNode(firstParentNode);
          TextModification modForUpdate = pathModMap.get(firstParentNodePath);
          if(modForUpdate == null){
            String content = nodeToString(evaluatedNode.getParentNode());
            TextModification newMod = new TextModification(firstParentNodePath, null, null, content);
            removeAllChildMods(pathModMap, firstParentNodePath);
            pathModMap.put(firstParentNodePath, newMod);
          }
          //else: It is already replaced
        }
      }
    }
    return true;
  }  // addNode()
  
  /**
   * Creates a TextModification that removes a node
   * @param pathModMap Map of the created text modifications
   * @param removeNode Node for removal
   * @param highestProtocol highest available protocol version
   * @param newVersion New version of the document
   */
  public static void removeNode(LinkedHashMap<String,TextModification> pathModMap, 
          NodeDetail removeNode, int highestProtocol, Document newVersion){
    if(!existsParentMod(pathModMap, removeNode.getXpathLocation())){
      if(highestProtocol < Constants.PROTOCOL_LOD_V2 &&
              (removeNode.getNode().getNodeName().equalsIgnoreCase("br") ||
              removeNode.getNode().getNodeName().equalsIgnoreCase("hr")))
      {
        //try to replace parent
        if(!replaceFirstParentNode(pathModMap, removeNode, newVersion, true)){
          TextModification tm = new TextModification(removeNode.getXpathLocation(), null, null, null);
          removeAllChildMods(pathModMap, removeNode.getXpathLocation());
          pathModMap.put(removeNode.getXpathLocation(), tm);
        }
      }
      else{
        TextModification tm = new TextModification(removeNode.getXpathLocation(), null, null, null);
        removeAllChildMods(pathModMap, removeNode.getXpathLocation());
        pathModMap.put(removeNode.getXpathLocation(), tm);
      }
    }
  }
  
  /**
   * Method creates a TextModification that replaces a parent node of some node
   * Replaced parent node must exist in the version of the document
   * 
   * @param pathModMap Map of the created text modifications
   * @param replaceNodeDetail Node for it's parent replace
   * @param version Version of the document where the parent must exist
   * @param replaceByDocumentNode If true then parent is replaced by the parent node from the
   *                              version of the document (variable version). If true then the parent node is replaced by 
   *                              the specified Node (variable replaceNodeDetail) parent.
   * @return True if success, otherwise false
   */
  public static boolean replaceFirstParentNode(LinkedHashMap<String,TextModification> pathModMap,
          NodeDetail replaceNodeDetail, Document version, boolean replaceByDocumentNode){
    if(!existsParentMod(pathModMap, replaceNodeDetail.getXpathLocation())){
      Node firstParentNode = null;
      Node evaluatedNode = replaceNodeDetail.getNode();
      // gets the first parent node that exists in the version of the document
      while(firstParentNode == null){
        firstParentNode = getParentIfExists(version, evaluatedNode);
        if(firstParentNode == null){
          evaluatedNode = evaluatedNode.getParentNode();
          if(evaluatedNode == null){
            return false;
          }
        }
      }
      // Creates a replace modification
      String firstParentNodePath = XPathHelper.XPathStringOfNode(firstParentNode);
      TextModification modForUpdate = pathModMap.get(firstParentNodePath);
      if(modForUpdate == null){
        String content = null;
        if(replaceByDocumentNode){
          content = nodeToString(firstParentNode);
        }
        else{
          content = nodeToString(evaluatedNode.getParentNode());
        }
        TextModification newMod = new TextModification(firstParentNodePath, null, null, content);
        removeAllChildMods(pathModMap, firstParentNodePath);
        pathModMap.put(firstParentNodePath, newMod);
      }
      //else: It is already replaced
    }
    return true;
  }
  
  /**
   * Method creates a TextModification that replaces a node
   * 
   * @param pathModMap Map of the created text modifications
   * @param replaceNodeDetail Node for replacement
   */
  public static void replaceNode(LinkedHashMap<String,TextModification> pathModMap,
          NodeDetail replaceNodeDetail)
  {
    String replacePath = replaceNodeDetail.getXpathLocation();
    if(!existsParentMod(pathModMap, replacePath)){
      // Don't replace br or hr
      if(replaceNodeDetail.getNode().getNodeName().equalsIgnoreCase("br") ||
            replaceNodeDetail.getNode().getNodeName().equalsIgnoreCase("hr"))
      {
        return;
      }
      // Replacement of the text node
      if(replaceNodeDetail.getNode().getNodeType() == Node.TEXT_NODE){
        TextModification tm = new TextModification(replacePath, null, null, replaceNodeDetail.getNode().getNodeValue());
        pathModMap.put(replacePath, tm);
      }
      // All other nodes replacement
      else{
        String content = nodeToString(replaceNodeDetail.getNode());
        TextModification newMod = new TextModification(replacePath, null, null, content);
        removeAllChildMods(pathModMap, replacePath);
        pathModMap.put(replacePath, newMod);
      }
    }
  }
}  // public class TextModificationsXMLUnitProvider