Clover coverage report - dom4j - 1.6.1
Coverage timestamp: ma mei 16 2005 14:23:01 GMT+01:00
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 412   Methods: 28
NCLOC: 154   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
DocumentHelper.java 95% 75,4% 50% 72,6%
coverage coverage
 1    /*
 2    * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 3    *
 4    * This software is open source.
 5    * See the bottom of this file for the licence.
 6    */
 7   
 8    package org.dom4j;
 9   
 10    import java.io.StringReader;
 11    import java.util.List;
 12    import java.util.Map;
 13    import java.util.StringTokenizer;
 14   
 15    import org.dom4j.io.SAXReader;
 16    import org.dom4j.rule.Pattern;
 17   
 18    import org.jaxen.VariableContext;
 19   
 20    import org.xml.sax.InputSource;
 21   
 22    /**
 23    * <p>
 24    * <code>DocumentHelper</code> is a collection of helper methods for using
 25    * DOM4J.
 26    * </p>
 27    *
 28    * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>
 29    * @version $Revision: 1.26 $
 30    */
 31    public final class DocumentHelper {
 32  0 private DocumentHelper() {
 33    }
 34   
 35  12496 private static DocumentFactory getDocumentFactory() {
 36  12496 return DocumentFactory.getInstance();
 37    }
 38   
 39    // Static helper methods
 40  412 public static Document createDocument() {
 41  412 return getDocumentFactory().createDocument();
 42    }
 43   
 44  2 public static Document createDocument(Element rootElement) {
 45  2 return getDocumentFactory().createDocument(rootElement);
 46    }
 47   
 48  2000 public static Element createElement(QName qname) {
 49  2000 return getDocumentFactory().createElement(qname);
 50    }
 51   
 52  4 public static Element createElement(String name) {
 53  4 return getDocumentFactory().createElement(name);
 54    }
 55   
 56  0 public static Attribute createAttribute(Element owner, QName qname,
 57    String value) {
 58  0 return getDocumentFactory().createAttribute(owner, qname, value);
 59    }
 60   
 61  0 public static Attribute createAttribute(Element owner, String name,
 62    String value) {
 63  0 return getDocumentFactory().createAttribute(owner, name, value);
 64    }
 65   
 66  0 public static CDATA createCDATA(String text) {
 67  0 return DocumentFactory.getInstance().createCDATA(text);
 68    }
 69   
 70  0 public static Comment createComment(String text) {
 71  0 return DocumentFactory.getInstance().createComment(text);
 72    }
 73   
 74  0 public static Text createText(String text) {
 75  0 return DocumentFactory.getInstance().createText(text);
 76    }
 77   
 78  0 public static Entity createEntity(String name, String text) {
 79  0 return DocumentFactory.getInstance().createEntity(name, text);
 80    }
 81   
 82  0 public static Namespace createNamespace(String prefix, String uri) {
 83  0 return DocumentFactory.getInstance().createNamespace(prefix, uri);
 84    }
 85   
 86  2 public static ProcessingInstruction createProcessingInstruction(String pi,
 87    String d) {
 88  2 return getDocumentFactory().createProcessingInstruction(pi, d);
 89    }
 90   
 91  0 public static ProcessingInstruction createProcessingInstruction(String pi,
 92    Map data) {
 93  0 return getDocumentFactory().createProcessingInstruction(pi, data);
 94    }
 95   
 96  0 public static QName createQName(String localName, Namespace namespace) {
 97  0 return getDocumentFactory().createQName(localName, namespace);
 98    }
 99   
 100  10000 public static QName createQName(String localName) {
 101  10000 return getDocumentFactory().createQName(localName);
 102    }
 103   
 104    /**
 105    * <p>
 106    * <code>createXPath</code> parses an XPath expression and creates a new
 107    * XPath <code>XPath</code> instance using the singleton {@link
 108    * DocumentFactory}.
 109    * </p>
 110    *
 111    * @param xpathExpression
 112    * is the XPath expression to create
 113    *
 114    * @return a new <code>XPath</code> instance
 115    *
 116    * @throws InvalidXPathException
 117    * if the XPath expression is invalid
 118    */
 119  57 public static XPath createXPath(String xpathExpression)
 120    throws InvalidXPathException {
 121  57 return getDocumentFactory().createXPath(xpathExpression);
 122    }
 123   
 124    /**
 125    * <p>
 126    * <code>createXPath</code> parses an XPath expression and creates a new
 127    * XPath <code>XPath</code> instance using the singleton {@link
 128    * DocumentFactory}.
 129    * </p>
 130    *
 131    * @param xpathExpression
 132    * is the XPath expression to create
 133    * @param context
 134    * is the variable context to use when evaluating the XPath
 135    *
 136    * @return a new <code>XPath</code> instance
 137    *
 138    * @throws InvalidXPathException
 139    * if the XPath expression is invalid
 140    */
 141  1 public static XPath createXPath(String xpathExpression,
 142    VariableContext context) throws InvalidXPathException {
 143  1 return getDocumentFactory().createXPath(xpathExpression, context);
 144    }
 145   
 146    /**
 147    * <p>
 148    * <code>createXPathFilter</code> parses a NodeFilter from the given XPath
 149    * filter expression using the singleton {@link DocumentFactory}. XPath
 150    * filter expressions occur within XPath expressions such as
 151    * <code>self::node()[ filterExpression ]</code>
 152    * </p>
 153    *
 154    * @param xpathFilterExpression
 155    * is the XPath filter expression to create
 156    *
 157    * @return a new <code>NodeFilter</code> instance
 158    */
 159  4 public static NodeFilter createXPathFilter(String xpathFilterExpression) {
 160  4 return getDocumentFactory().createXPathFilter(xpathFilterExpression);
 161    }
 162   
 163    /**
 164    * <p>
 165    * <code>createPattern</code> parses the given XPath expression to create
 166    * an XSLT style {@link Pattern}instance which can then be used in an XSLT
 167    * processing model.
 168    * </p>
 169    *
 170    * @param xpathPattern
 171    * is the XPath pattern expression to create
 172    *
 173    * @return a new <code>Pattern</code> instance
 174    */
 175  14 public static Pattern createPattern(String xpathPattern) {
 176  14 return getDocumentFactory().createPattern(xpathPattern);
 177    }
 178   
 179    /**
 180    * <p>
 181    * <code>selectNodes</code> performs the given XPath expression on the
 182    * {@link List}of {@link Node}instances appending all the results together
 183    * into a single list.
 184    * </p>
 185    *
 186    * @param xpathFilterExpression
 187    * is the XPath filter expression to evaluate
 188    * @param nodes
 189    * is the list of nodes on which to evalute the XPath
 190    *
 191    * @return the results of all the XPath evaluations as a single list
 192    */
 193  0 public static List selectNodes(String xpathFilterExpression, List nodes) {
 194  0 XPath xpath = createXPath(xpathFilterExpression);
 195   
 196  0 return xpath.selectNodes(nodes);
 197    }
 198   
 199    /**
 200    * <p>
 201    * <code>selectNodes</code> performs the given XPath expression on the
 202    * {@link List}of {@link Node}instances appending all the results together
 203    * into a single list.
 204    * </p>
 205    *
 206    * @param xpathFilterExpression
 207    * is the XPath filter expression to evaluate
 208    * @param node
 209    * is the Node on which to evalute the XPath
 210    *
 211    * @return the results of all the XPath evaluations as a single list
 212    */
 213  0 public static List selectNodes(String xpathFilterExpression, Node node) {
 214  0 XPath xpath = createXPath(xpathFilterExpression);
 215   
 216  0 return xpath.selectNodes(node);
 217    }
 218   
 219    /**
 220    * <p>
 221    * <code>sort</code> sorts the given List of Nodes using an XPath
 222    * expression as a {@link java.util.Comparator}.
 223    * </p>
 224    *
 225    * @param list
 226    * is the list of Nodes to sort
 227    * @param xpathExpression
 228    * is the XPath expression used for comparison
 229    */
 230  0 public static void sort(List list, String xpathExpression) {
 231  0 XPath xpath = createXPath(xpathExpression);
 232  0 xpath.sort(list);
 233    }
 234   
 235    /**
 236    * <p>
 237    * <code>sort</code> sorts the given List of Nodes using an XPath
 238    * expression as a {@link java.util.Comparator}and optionally removing
 239    * duplicates.
 240    * </p>
 241    *
 242    * @param list
 243    * is the list of Nodes to sort
 244    * @param expression
 245    * is the XPath expression used for comparison
 246    * @param distinct
 247    * if true then duplicate values (using the sortXPath for
 248    * comparisions) will be removed from the List
 249    */
 250  0 public static void sort(List list, String expression, boolean distinct) {
 251  0 XPath xpath = createXPath(expression);
 252  0 xpath.sort(list, distinct);
 253    }
 254   
 255    /**
 256    * <p>
 257    * <code>parseText</code> parses the given text as an XML document and
 258    * returns the newly created Document.
 259    * </p>
 260    *
 261    * @param text
 262    * the XML text to be parsed
 263    *
 264    * @return a newly parsed Document
 265    *
 266    * @throws DocumentException
 267    * if the document could not be parsed
 268    */
 269  5552 public static Document parseText(String text) throws DocumentException {
 270  5552 Document result = null;
 271   
 272  5552 SAXReader reader = new SAXReader();
 273  5552 String encoding = getEncoding(text);
 274   
 275  5552 InputSource source = new InputSource(new StringReader(text));
 276  5552 source.setEncoding(encoding);
 277   
 278  5552 result = reader.read(source);
 279   
 280    // if the XML parser doesn't provide a way to retrieve the encoding,
 281    // specify it manually
 282  5552 if (result.getXMLEncoding() == null) {
 283  5528 result.setXMLEncoding(encoding);
 284    }
 285   
 286  5552 return result;
 287    }
 288   
 289  5552 private static String getEncoding(String text) {
 290  5552 String result = null;
 291   
 292  5552 String xml = text.trim();
 293   
 294  5552 if (xml.startsWith("<?xml")) {
 295  25 int end = xml.indexOf("?>");
 296  25 String sub = xml.substring(0, end);
 297  25 StringTokenizer tokens = new StringTokenizer(sub, " =\"\'");
 298   
 299  25 while (tokens.hasMoreTokens()) {
 300  99 String token = tokens.nextToken();
 301   
 302  99 if ("encoding".equals(token)) {
 303  24 if (tokens.hasMoreTokens()) {
 304  24 result = tokens.nextToken();
 305    }
 306   
 307  24 break;
 308    }
 309    }
 310    }
 311   
 312  5552 return result;
 313    }
 314   
 315    /**
 316    * <p>
 317    * makeElement
 318    * </p>
 319    * a helper method which navigates from the given Document or Element node
 320    * to some Element using the path expression, creating any necessary
 321    * elements along the way. For example the path <code>a/b/c</code> would
 322    * get the first child &lt;a&gt; element, which would be created if it did
 323    * not exist, then the next child &lt;b&gt; and so on until finally a
 324    * &lt;c&gt; element is returned.
 325    *
 326    * @param source
 327    * is the Element or Document to start navigating from
 328    * @param path
 329    * is a simple path expression, seperated by '/' which denotes
 330    * the path from the source to the resulting element such as
 331    * a/b/c
 332    *
 333    * @return the first Element on the given path which either already existed
 334    * on the path or were created by this method.
 335    */
 336  6 public static Element makeElement(Branch source, String path) {
 337  6 StringTokenizer tokens = new StringTokenizer(path, "/");
 338  6 Element parent;
 339   
 340  6 if (source instanceof Document) {
 341  4 Document document = (Document) source;
 342  4 parent = document.getRootElement();
 343   
 344    // lets throw a NoSuchElementException
 345    // if we are given an empty path
 346  4 String name = tokens.nextToken();
 347   
 348  4 if (parent == null) {
 349  1 parent = document.addElement(name);
 350    }
 351    } else {
 352  2 parent = (Element) source;
 353    }
 354   
 355  6 Element element = null;
 356   
 357  6 while (tokens.hasMoreTokens()) {
 358  14 String name = tokens.nextToken();
 359   
 360  14 if (name.indexOf(':') > 0) {
 361  4 element = parent.element(parent.getQName(name));
 362    } else {
 363  10 element = parent.element(name);
 364    }
 365   
 366  14 if (element == null) {
 367  6 element = parent.addElement(name);
 368    }
 369   
 370  14 parent = element;
 371    }
 372   
 373  6 return element;
 374    }
 375    }
 376   
 377    /*
 378    * Redistribution and use of this software and associated documentation
 379    * ("Software"), with or without modification, are permitted provided that the
 380    * following conditions are met:
 381    *
 382    * 1. Redistributions of source code must retain copyright statements and
 383    * notices. Redistributions must also contain a copy of this document.
 384    *
 385    * 2. Redistributions in binary form must reproduce the above copyright notice,
 386    * this list of conditions and the following disclaimer in the documentation
 387    * and/or other materials provided with the distribution.
 388    *
 389    * 3. The name "DOM4J" must not be used to endorse or promote products derived
 390    * from this Software without prior written permission of MetaStuff, Ltd. For
 391    * written permission, please contact dom4j-info@metastuff.com.
 392    *
 393    * 4. Products derived from this Software may not be called "DOM4J" nor may
 394    * "DOM4J" appear in their names without prior written permission of MetaStuff,
 395    * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
 396    *
 397    * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
 398    *
 399    * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
 400    * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 401    * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 402    * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
 403    * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 404    * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 405    * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 406    * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 407    * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 408    * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 409    * POSSIBILITY OF SUCH DAMAGE.
 410    *
 411    * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 412    */
 
CloverReport generated by Clover Code Coverage v1.3.5
ma mei 16 2005 14:23:02 GMT+01:00.		   Open Source License registered to the dom4j Project. This license of Clover is provided to support the development of dom4j only.