source: trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/xpointer/XPointer.java@ 6290

package org.greenstone.gsdl3.gs3build.xpointer;

import java.io.File; 

import java.net.URL;

import javax.xml.parsers.*;

import org.w3c.dom.*;
import org.apache.xpath.*;
import org.w3c.tidy.Tidy;

import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.helpers.DefaultHandler;

import org.greenstone.gsdl3.gs3build.doctypes.HTMLDocumentTools;
import org.greenstone.gsdl3.gs3build.util.HTMLTidy;

public abstract class XPointer
{
  Document document;  
  String   xpointer;

  public XPointer(org.w3c.dom.Document document, String xpointer)
  { this.document = document;
    this.xpointer = xpointer;
    // now process the type of description
  }

  public static String expandXPath(String xpath)
  {
    int          dashAt;
    String       pathElement;
    StringBuffer expandedPtr = new StringBuffer();

    if (xpath.startsWith("//")) {
      xpath = xpath.substring(2);
      expandedPtr.append("//");
    }
    else if (xpath.startsWith("/")) {
      xpath = xpath.substring(1);
      expandedPtr.append("/");
    }

    while (xpath.length() > 0) {
      dashAt = xpath.indexOf('/');
      if (dashAt >= 0) {
    pathElement = xpath.substring(0, dashAt);
    xpath = xpath.substring(dashAt+1);
      }
      else {
    pathElement = xpath;
    xpath = "";
      }

      int c = 0;
      while (c < pathElement.length()) {
    if (!Character.isDigit(pathElement.charAt(c))) 
      break;
    c ++;
      }

      if (c == pathElement.length()) {
    expandedPtr.append("*[");
    expandedPtr.append(pathElement);
    expandedPtr.append("]");
      }
      else {
    expandedPtr.append(pathElement);
      }

      if (dashAt >= 0) {
    expandedPtr.append('/');
      }
    }
    xpath = expandedPtr.toString();

    return xpath;
  }

  public static XPointer processXPointer(Document document, String xpointer)
  { // do a "cheap and dirty" detection of range-to
    if (xpointer.indexOf("range-to") >= 0) {
      return new RangeToXPointer(document, xpointer);
    } 
    return new IdentifierXPointer(document, xpointer);
  }

  public static XPointer processXPointer(Document document, URL url)
  { String reference = url.getRef();

    reference.trim();
    if (reference.startsWith("xpointer(")) {
      reference = reference.substring(9, reference.length() - 1);
    }
    else {
      return null;
    }
    //    System.out.println(reference);
    
    return processXPointer(document, reference);
  }

  public static void printNode(Node node, StringBuffer to, boolean close)
  {
    if (node.getNodeType() == org.w3c.dom.Node.TEXT_NODE) {
      if (!close) {
    to.append(node.getNodeValue());
      }
    }
    else if (node.getNodeType() == org.w3c.dom.Node.ENTITY_NODE) {
      if (!close) {
    to.append("&");
    to.append(node.getNodeValue());
    to.append(";");
      }
    }
    else if (node.getNodeType() == org.w3c.dom.Node.COMMENT_NODE) {
      if (!close) {
    to.append("<!-- ");
    to.append(node.getNodeValue());
    to.append(" -->");
      }
    }
    else if (node.getNodeType() == org.w3c.dom.Node.ELEMENT_NODE) {
      boolean hasChildren = (node.getChildNodes().getLength() > 0);

      if (close && !hasChildren) {
    return;
      }
      to.append("<");
      if (close) {
    to.append("/");
      }
      to.append(node.getNodeName());

      if (!close) {
    NamedNodeMap attributes = ((Element) node).getAttributes();
    for (int a = 0; a < attributes.getLength(); a ++) {
      Node attributeNode = attributes.item(a);
      to.append(" ");
      to.append(attributeNode.getNodeName());
      
      String value = attributeNode.getNodeValue();
      if (value != null && value.length() > 0) {
        to.append("=\"");
        to.append(value);
        to.append("\"");
      }
    }
      }

      if (!hasChildren) {
    to.append(" /");
      }
      to.append(">");
    }
  }

  public static Node getNextNode(Node currentNode, StringBuffer buffer)
  { Node reply;

    // Try for children only the once...
    NodeList children = currentNode.getChildNodes();
    for (int c = 0; c < children.getLength(); c++) {
      Node childNode = children.item(c);

      if (childNode.getNodeType() == org.w3c.dom.Node.ELEMENT_NODE ||
      childNode.getNodeType() == org.w3c.dom.Node.COMMENT_NODE ||
      childNode.getNodeType() == org.w3c.dom.Node.TEXT_NODE ||
      childNode.getNodeType() == org.w3c.dom.Node.ENTITY_NODE) {
    return childNode;
      }
    }

    // Repeat looking for a sibling & going up until done...
    do {
      reply = currentNode.getNextSibling();
      if (reply != null) {
    return reply;
      }
      
      currentNode = currentNode.getParentNode();
      if (buffer != null && currentNode != null) {
    printNode(currentNode, buffer, true);
      }
    } while (currentNode != null);

    return reply;
  }

  public abstract Node getStartNode();


  public static void main(String args[])
  { 
    try
    { File file = new File(args[0]);

      Document document;
      if (args[0].endsWith(".html") || args[0].endsWith(".htm")) {
    Tidy tidy = new Tidy();
    tidy.setMakeClean(true);
    tidy.setXmlTags(true);
    document = tidy.parseDOM(new java.io.FileInputStream(file), null);

    HTMLTidy tidier = new HTMLTidy(file);
    document = tidier.getDocument();

    HTMLDocumentTools docTools = new HTMLDocumentTools(document);
    docTools.findSections();
    System.out.println("Sections found");
      }
      else {
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    document = builder.parse(file);
      }
      
      XPointer pointer;
      if (args.length == 2) {
    pointer = XPointer.processXPointer(document, args[1]);
      }
      else {
    pointer = XPointer.processXPointer(document, args[1]+"/range-to("+args[2]+")");
      }
      System.out.println(pointer.toString());
    }
    catch (FactoryConfigurationError e) {
      System.err.println(e);
    }
    catch (ParserConfigurationException ex) {
      System.err.println(ex);
    }
    catch (SAXException ex) {
      System.err.println(ex);
    }
    catch (java.io.IOException ex) {
      System.err.println(ex);
    }
  }
}