RELEASE_2_1_13/src/java/org/apache/cocoon/bean/helpers/BeanConfigurator.java - cocoon - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.cocoon.bean.helpers;

 import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;

 import org.apache.cocoon.bean.CocoonBean;
 import org.apache.cocoon.bean.helpers.OutputStreamListener;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang.BooleanUtils;

 import org.w3c.dom.Document;
 import org.w3c.dom.NamedNodeMap;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 /**
  * Static class for configuring a CocoonBean from a DOM Document object
  *
  * @author <a href="mailto:uv@upaya.co.uk">Upayavira</a>
  * @version CVS $Id$
  */
 public class BeanConfigurator {

     private static final String NODE_ROOT = "cocoon";
     private static final String ATTR_VERBOSE = "verbose";

     private static final String NODE_LOGGING = "logging";
     private static final String ATTR_LOG_KIT = "log-kit";
     private static final String ATTR_LOG_LEVEL = "level";
     private static final String ATTR_LOGGER = "logger";

     private static final String NODE_CONTEXT_DIR = "context-dir";
     private static final String NODE_DEST_DIR = "dest-dir";
     private static final String NODE_WORK_DIR = "work-dir";
     private static final String NODE_CONFIG_FILE = "config-file";
     private static final String NODE_URI_FILE = "uri-file";
     private static final String NODE_CHECKSUMS_URI = "checksums-uri";

     private static final String ATTR_CONTEXT_DIR = "context-dir";
     private static final String ATTR_DEST_DIR = "dest-dir";
     private static final String ATTR_WORK_DIR = "work-dir";
     private static final String ATTR_CONFIG_FILE = "config-file";
     private static final String ATTR_URI_FILE = "uri-file";
     private static final String ATTR_CHECKSUMS_URI = "checksums-uri";
     private static final String ATTR_AGENT = "user-agent";
     private static final String ATTR_ACCEPT = "accept";
     private static final String ATTR_DEFAULT_FILENAME = "default-filename";

     private static final String NODE_BROKEN_LINKS = "broken-links";
     private static final String ATTR_BROKEN_LINK_REPORT_TYPE = "type";
     private static final String ATTR_BROKEN_LINK_REPORT_FILE = "file";
     private static final String ATTR_BROKEN_LINK_GENERATE = "generate";
     private static final String ATTR_BROKEN_LINK_EXTENSION = "extension";

     private static final String NODE_AGENT = "user-agent";
     private static final String NODE_ACCEPT = "accept";

     private static final String ATTR_FOLLOW_LINKS = "follow-links";
     private static final String ATTR_PRECOMPILE_ONLY = "precompile-only";
     private static final String ATTR_CONFIRM_EXTENSIONS = "confirm-extensions";
     private static final String NODE_LOAD_CLASS = "load-class";
     private static final String NODE_DEFAULT_FILENAME = "default-filename";

     private static final String NODE_INCLUDE = "include";
     private static final String NODE_EXCLUDE = "exclude";
     private static final String ATTR_INCLUDE_EXCLUDE_PATTERN = "pattern";

     private static final String NODE_INCLUDE_LINKS = "include-links";
     private static final String ATTR_LINK_EXTENSION = "extension";

     private static final String NODE_URI = "uri";
     private static final String ATTR_URI_TYPE = "type";
     private static final String ATTR_URI_SOURCEPREFIX = "src-prefix";
     private static final String ATTR_URI_SOURCEURI = "src";
     private static final String ATTR_URI_DESTURI = "dest";

     private static final String NODE_URIS = "uris";
     private static final String ATTR_NAME = "name";

     public static String configure(Document xconf, CocoonBean cocoon, String destDir, String uriGroup, OutputStreamListener listener)
         throws IllegalArgumentException {

         Node root = xconf.getDocumentElement();
         if (!NODE_ROOT.equals(root.getNodeName())) {
             throw new IllegalArgumentException("Expected root node of "+ NODE_ROOT);
         }

         if (hasAttribute(root, ATTR_VERBOSE)) {
             cocoon.setVerbose(getBooleanAttributeValue(root, ATTR_VERBOSE));
         }
         if (hasAttribute(root, ATTR_FOLLOW_LINKS)) {
             cocoon.setFollowLinks(getBooleanAttributeValue(root, ATTR_FOLLOW_LINKS));
         }
         if (hasAttribute(root, ATTR_PRECOMPILE_ONLY)) {
             cocoon.setPrecompileOnly(getBooleanAttributeValue(root, ATTR_PRECOMPILE_ONLY));
         }
         if (hasAttribute(root, ATTR_CONFIRM_EXTENSIONS)) {
             cocoon.setConfirmExtensions(getBooleanAttributeValue(root, ATTR_CONFIRM_EXTENSIONS));
         }
         if (hasAttribute(root, ATTR_CONTEXT_DIR)) {
             cocoon.setContextDir(getAttributeValue(root, ATTR_CONTEXT_DIR));
         }
         if (hasAttribute(root, ATTR_DEST_DIR)) {
             destDir = getAttributeValue(root, ATTR_DEST_DIR);
         }
         if (hasAttribute(root, ATTR_WORK_DIR)) {
             cocoon.setWorkDir(getAttributeValue(root, ATTR_WORK_DIR));
         }
         if (hasAttribute(root, ATTR_CONFIG_FILE)) {
             cocoon.setConfigFile(getAttributeValue(root, ATTR_CONFIG_FILE));
         }
         if (hasAttribute(root, ATTR_URI_FILE)) {
             cocoon.addTargets(processURIFile(getAttributeValue(root, ATTR_URI_FILE)), destDir);
         }
         if (hasAttribute(root, ATTR_CHECKSUMS_URI)) {
             cocoon.setChecksumURI(getAttributeValue(root, ATTR_CHECKSUMS_URI));
         }
         if (hasAttribute(root, ATTR_AGENT)) {
             cocoon.setAgentOptions(getAttributeValue(root, ATTR_AGENT));
         }
         if (hasAttribute(root, ATTR_ACCEPT)) {
             cocoon.setAcceptOptions(getAttributeValue(root, ATTR_ACCEPT));
         }
         if (hasAttribute(root, ATTR_DEFAULT_FILENAME)) {
             cocoon.setDefaultFilename(getAttributeValue(root, ATTR_DEFAULT_FILENAME));
         }

         if (destDir == null || destDir.length() == 0) {
             destDir = getNodeValue(root, NODE_DEST_DIR);
         }

         NodeList nodes = root.getChildNodes();
         for (int i = 0; i < nodes.getLength(); i++) {
             Node node = nodes.item(i);
             if (node.getNodeType()== Node.ELEMENT_NODE) {
                 String nodeName = node.getNodeName();
                 if (nodeName.equals(NODE_BROKEN_LINKS)) {
                     parseBrokenLinkNode(cocoon, node, listener);

                 } else if (nodeName.equals(NODE_LOAD_CLASS)) {
                     cocoon.addLoadedClass(getNodeValue(node));

                 } else if (nodeName.equals(NODE_LOGGING)) {
                     parseLoggingNode(cocoon, node);

                 } else if (nodeName.equals(NODE_CONTEXT_DIR)) {
                     if (hasAttribute(root, ATTR_CONTEXT_DIR)) {
                         throw new IllegalArgumentException("Cannot have "+NODE_CONTEXT_DIR+" as both element and attribute");
                     } else {
                         cocoon.setContextDir(getNodeValue(node));
                     }

                 } else if (nodeName.equals(NODE_CONFIG_FILE)) {
                     if (hasAttribute(root, ATTR_CONFIG_FILE)) {
                         throw new IllegalArgumentException("Cannot have "+NODE_CONFIG_FILE+" as both element and attribute");
                     } else {
                         cocoon.setConfigFile(getNodeValue(node));
                     }
                 } else if (nodeName.equals(NODE_DEST_DIR)) {
                     // Ignore

                 } else if (nodeName.equals(NODE_WORK_DIR)) {
                     if (hasAttribute(root, ATTR_WORK_DIR)) {
                         throw new IllegalArgumentException("Cannot have "+NODE_WORK_DIR+" as both element and attribute");
                     } else {
                         cocoon.setWorkDir(getNodeValue(node));
                     }
                 } else if (nodeName.equals(NODE_CHECKSUMS_URI)) {
                     if (hasAttribute(root, ATTR_CHECKSUMS_URI)) {
                         throw new IllegalArgumentException("Cannot have "+NODE_CHECKSUMS_URI+" as both element and attribute");
                     } else {
                         cocoon.setChecksumURI(getNodeValue(node));
                     }
                 } else if (nodeName.equals(NODE_AGENT)) {
                     cocoon.setAgentOptions(getNodeValue(node));

                 } else if (nodeName.equals(NODE_ACCEPT)) {
                     cocoon.setAcceptOptions(getNodeValue(node));

                 } else if (nodeName.equals(NODE_DEFAULT_FILENAME)) {
                     cocoon.setDefaultFilename(getNodeValue(node));

                 } else if (nodeName.equals(NODE_INCLUDE)) {
                     String pattern = parseIncludeExcludeNode(cocoon, node, NODE_INCLUDE);
                     cocoon.addIncludePattern(pattern);

                 } else if (nodeName.equals(NODE_EXCLUDE)) {
                     String pattern = parseIncludeExcludeNode(cocoon, node, NODE_EXCLUDE);
                     cocoon.addExcludePattern(pattern);

                 } else if (nodeName.equals(NODE_INCLUDE_LINKS)) {
                     parseIncludeLinksNode(cocoon, node);

                 } else if (nodeName.equals(NODE_URI)) {
                     parseURINode(cocoon, node, destDir);

                 } else if (nodeName.equals(NODE_URIS)) {
                     parseURIsNode(cocoon, node, destDir, uriGroup);

                 } else if (nodeName.equals(NODE_URI_FILE)) {
                     if (hasAttribute(root, ATTR_URI_FILE)) {
                         throw new IllegalArgumentException("Cannot have "+NODE_URI_FILE+" as both element and attribute");
                     } else {
                         cocoon.addTargets(processURIFile(getNodeValue(node)), destDir);
                     }
                 } else {
                     throw new IllegalArgumentException("Unknown element: <" + nodeName + ">");
                 }
             }
         }
         return destDir;
     }

     private static void parseLoggingNode(CocoonBean cocoon, Node node) throws IllegalArgumentException {
         if (hasAttribute(node, ATTR_LOG_KIT)) {
             cocoon.setLogKit(getAttributeValue(node, ATTR_LOG_KIT));
         }
         if (hasAttribute(node, ATTR_LOGGER)) {
             cocoon.setLogger(getAttributeValue(node, ATTR_LOGGER));
         }
         if (hasAttribute(node, ATTR_LOG_LEVEL)) {
             cocoon.setLogLevel(getAttributeValue(node, ATTR_LOG_LEVEL));
         }
         NodeList nodes = node.getChildNodes();
         if (nodes.getLength()!=0) {
             throw new IllegalArgumentException("Unexpected children of <" + NODE_LOGGING + "> node");
         }
     }

     private static void parseIncludeLinksNode(CocoonBean cocoon, Node node) throws IllegalArgumentException {
         if (hasAttribute(node, ATTR_LINK_EXTENSION)) {
             cocoon.addIncludeLinkExtension(getAttributeValue(node, ATTR_LINK_EXTENSION));
         }
     }

     private static void parseBrokenLinkNode(CocoonBean cocoon, Node node, OutputStreamListener listener) throws IllegalArgumentException {
         if (hasAttribute(node, ATTR_BROKEN_LINK_REPORT_FILE)) {
             listener.setReportFile(getAttributeValue(node, ATTR_BROKEN_LINK_REPORT_FILE));
         }
         if (hasAttribute(node, ATTR_BROKEN_LINK_REPORT_TYPE)) {
             listener.setReportType(getAttributeValue(node, ATTR_BROKEN_LINK_REPORT_TYPE));
         }
         if (hasAttribute(node, ATTR_BROKEN_LINK_GENERATE)) {
         cocoon.setBrokenLinkGenerate(getBooleanAttributeValue(node, ATTR_BROKEN_LINK_GENERATE));
         }
         if (hasAttribute(node, ATTR_BROKEN_LINK_EXTENSION)) {
         cocoon.setBrokenLinkExtension(getAttributeValue(node, ATTR_BROKEN_LINK_EXTENSION));
         }
         NodeList nodes = node.getChildNodes();
         if (nodes.getLength()!=0) {
             throw new IllegalArgumentException("Unexpected children of <" + NODE_BROKEN_LINKS + "> node");
         }
     }

     private static String parseIncludeExcludeNode(CocoonBean cocoon, Node node, final String NODE_TYPE) throws IllegalArgumentException {
         NodeList nodes = node.getChildNodes();
         if (nodes.getLength() != 0) {
             throw new IllegalArgumentException("Unexpected children of <" + NODE_INCLUDE + "> node");
         }

         if (hasAttribute(node, ATTR_INCLUDE_EXCLUDE_PATTERN)) {
             return getAttributeValue(node, ATTR_INCLUDE_EXCLUDE_PATTERN);
         } else {
             throw new IllegalArgumentException("Expected a "+ATTR_INCLUDE_EXCLUDE_PATTERN+" attribute for <"+NODE_TYPE+"> node");
         }
     }

     private static void parseURIsNode(CocoonBean cocoon, Node node, String destDir, String uriGroup) throws IllegalArgumentException {

         boolean followLinks = cocoon.followLinks();
         boolean confirmExtensions = cocoon.confirmExtensions();
         String logger = cocoon.getLoggerName();
         String destURI = destDir;
         String root = null;
         String type = null;
         String name = null;

         if (hasAttribute(node, ATTR_FOLLOW_LINKS)) {
             followLinks = getBooleanAttributeValue(node, ATTR_FOLLOW_LINKS);
         }
         if (hasAttribute(node, ATTR_CONFIRM_EXTENSIONS)) {
             confirmExtensions = getBooleanAttributeValue(node, ATTR_CONFIRM_EXTENSIONS);
         }
         if (hasAttribute(node, ATTR_URI_TYPE)) {
             type = getAttributeValue(node, ATTR_URI_TYPE);
         }
         if (hasAttribute(node, ATTR_URI_SOURCEPREFIX)) {
             root = getAttributeValue(node, ATTR_URI_SOURCEPREFIX);
         }
         if (hasAttribute(node, ATTR_URI_DESTURI)) {
             destURI = getAttributeValue(node, ATTR_URI_DESTURI);
         }
         if (hasAttribute(node, ATTR_LOGGER)) {
             logger = getAttributeValue(node, ATTR_LOGGER);
         }
         if (hasAttribute(node, ATTR_NAME)) {
             name = getAttributeValue(node, ATTR_NAME);
             if (name != null && uriGroup != null && !name.equals(uriGroup)) {
                 // The user has not selected this URI group, so ignore it.
                 return;
             }
         }
         NodeList nodes = node.getChildNodes();
         for (int i = 0; i < nodes.getLength(); i++) {
             Node child = nodes.item(i);
             if (child.getNodeType()== Node.ELEMENT_NODE) {
                 String childName = child.getNodeName();
                 if (childName.equals(NODE_URI)) {
                     String _sourceURI = null;
                     String _destURI = destURI;
                     String _root = root;
                     String _type = type;

                     if (child.getAttributes().getLength() == 0) {
                         _sourceURI = getNodeValue(child);
                         //destURI is inherited
                     } else {
                         _sourceURI = getAttributeValue(child, ATTR_URI_SOURCEURI);

                         if (hasAttribute(child, ATTR_URI_TYPE)) {
                             _type = getAttributeValue(child, ATTR_URI_TYPE);
                         }
                         if (hasAttribute(child, ATTR_URI_SOURCEPREFIX)) {
                             _root = getAttributeValue(child, ATTR_URI_SOURCEPREFIX);
                         }
                         if (hasAttribute(child, ATTR_URI_DESTURI)) {
                             _destURI = getAttributeValue(child, ATTR_URI_DESTURI);
                         }
                     }
                     cocoon.addTarget(_type, _root, _sourceURI, _destURI, followLinks, confirmExtensions, logger);
                 } else {
                     throw new IllegalArgumentException("Unknown element: <" + childName + ">");
                 }
             }
         }
     }

     private static void parseURINode(CocoonBean cocoon, Node node, String destDir) throws IllegalArgumentException {
         NodeList nodes = node.getChildNodes();

         if (node.getAttributes().getLength() == 0 && nodes.getLength() != 0) {
             cocoon.addTarget(getNodeValue(node), destDir);
         } else if (node.getAttributes().getLength() !=0 && nodes.getLength() ==0){

             String src = getAttributeValue(node, ATTR_URI_SOURCEURI);

             String type = null;
             if (hasAttribute(node, ATTR_URI_TYPE)) {
                 type = getAttributeValue(node, ATTR_URI_TYPE);
             }
             String root = null;
             if (hasAttribute(node, ATTR_URI_SOURCEPREFIX)) {
                 root = getAttributeValue(node, ATTR_URI_SOURCEPREFIX);
             }
             String dest = null;
             if (hasAttribute(node, ATTR_URI_DESTURI)) {
                 dest = getAttributeValue(node, ATTR_URI_DESTURI);
             }

             if (root != null && type != null && dest != null) {
                 cocoon.addTarget(type, root, src, dest);
             } else if (root != null && dest != null) {
                 cocoon.addTarget(root, src, dest);
             } else if (dest != null) {
                 cocoon.addTarget(src, dest);
             } else {
                 cocoon.addTarget(src, destDir);
             }
         } else if (node.getAttributes().getLength() !=0 && nodes.getLength() != 0) {
             throw new IllegalArgumentException("Unexpected children of <" + NODE_URI + "> node");
         } else {
             throw new IllegalArgumentException("Not enough information for <"+ NODE_URI + "> node");
         }
     }

     private static String getNodeValue(Node root, String name) throws IllegalArgumentException {
         NodeList nodes = root.getChildNodes();
         for (int i = 0; i < nodes.getLength(); i++) {
             Node node = nodes.item(i);
             if (node.getNodeType()== Node.ELEMENT_NODE) {
                 String nodeName = node.getNodeName();
                 if (nodeName.equals(name)) {
                     return getNodeValue(node);
                 }
             }
         }
         return null;
     }

     private static String getNodeValue(Node node) throws IllegalArgumentException {
         StringBuffer s = new StringBuffer();
         NodeList children = node.getChildNodes();
         boolean found = false;

         for (int i = 0; i < children.getLength(); i++) {
             Node child = children.item(i);
             if (child.getNodeType() == Node.TEXT_NODE) {
                 s.append(child.getNodeValue());
                 found = true;
             } else {
                 throw new IllegalArgumentException("Unexpected node:" + child.getLocalName());
             }
         }
         if (!found) {
             throw new IllegalArgumentException("Expected value for " + node.getLocalName() + " node");
         }
         return s.toString();
     }

     private static String getAttributeValue(Node node, String attr) throws IllegalArgumentException {
         NamedNodeMap nodes = node.getAttributes();
         if (nodes != null) {
             Node attribute = nodes.getNamedItem(attr);
             if (attribute != null && attribute.getNodeValue() != null) {
                 return attribute.getNodeValue();
             }
         }
         throw new IllegalArgumentException("Missing " + attr + " attribute on <" + node.getNodeName() + "> node");
     }

     private static boolean hasAttribute(Node node, String attr) {
         NamedNodeMap nodes = node.getAttributes();
         if (nodes != null) {
             Node attribute = nodes.getNamedItem(attr);
             return (attribute != null);
         }
         return false;
     }

     private static boolean getBooleanAttributeValue(Node node, String attr) {
         NamedNodeMap nodes = node.getAttributes();
         if (nodes != null) {
             Node attribute = nodes.getNamedItem(attr);

             if (attribute != null) {
                 String value = attribute.getNodeValue();
                 return BooleanUtils.toBoolean(value);
             }
         }
         return false;
     }

     /**
      * <code>processURIFile</code> method.
      *
      * @param filename a <code>String</code> value
      * @return uris a <code>List</code> of URIs
      */
     public static List processURIFile(String filename) {
         List uris = new ArrayList();
         FileReader fr = null;
         BufferedReader uriFile = null;
         try {
             fr = new FileReader(filename);
             uriFile = new BufferedReader(fr);
             String uri;
             while ((uri = uriFile.readLine()) != null) {
                 uri = uri.trim();
                 if (!uri.equals("") && !uri.startsWith("#")) {
                     uris.add(uri.trim());
                 }
             }
         } catch (FileNotFoundException e) {
             // nothing to do
         } catch (IOException e) {
             // nothing to do
         } finally {
             IOUtils.closeQuietly(uriFile);
             IOUtils.closeQuietly(fr);
         }
         return uris;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.cocoon.bean.helpers;

	import java.io.BufferedReader;
	import java.io.FileNotFoundException;
	import java.io.FileReader;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.List;

	import org.apache.cocoon.bean.CocoonBean;
	import org.apache.cocoon.bean.helpers.OutputStreamListener;
	import org.apache.commons.io.IOUtils;
	import org.apache.commons.lang.BooleanUtils;

	import org.w3c.dom.Document;
	import org.w3c.dom.NamedNodeMap;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	/**
	* Static class for configuring a CocoonBean from a DOM Document object
	*
	* @author <a href="mailto:uv@upaya.co.uk">Upayavira</a>
	* @version CVS $Id$
	*/
	public class BeanConfigurator {

	private static final String NODE_ROOT = "cocoon";
	private static final String ATTR_VERBOSE = "verbose";

	private static final String NODE_LOGGING = "logging";
	private static final String ATTR_LOG_KIT = "log-kit";
	private static final String ATTR_LOG_LEVEL = "level";
	private static final String ATTR_LOGGER = "logger";

	private static final String NODE_CONTEXT_DIR = "context-dir";
	private static final String NODE_DEST_DIR = "dest-dir";
	private static final String NODE_WORK_DIR = "work-dir";
	private static final String NODE_CONFIG_FILE = "config-file";
	private static final String NODE_URI_FILE = "uri-file";
	private static final String NODE_CHECKSUMS_URI = "checksums-uri";

	private static final String ATTR_CONTEXT_DIR = "context-dir";
	private static final String ATTR_DEST_DIR = "dest-dir";
	private static final String ATTR_WORK_DIR = "work-dir";
	private static final String ATTR_CONFIG_FILE = "config-file";
	private static final String ATTR_URI_FILE = "uri-file";
	private static final String ATTR_CHECKSUMS_URI = "checksums-uri";
	private static final String ATTR_AGENT = "user-agent";
	private static final String ATTR_ACCEPT = "accept";
	private static final String ATTR_DEFAULT_FILENAME = "default-filename";

	private static final String NODE_BROKEN_LINKS = "broken-links";
	private static final String ATTR_BROKEN_LINK_REPORT_TYPE = "type";
	private static final String ATTR_BROKEN_LINK_REPORT_FILE = "file";
	private static final String ATTR_BROKEN_LINK_GENERATE = "generate";
	private static final String ATTR_BROKEN_LINK_EXTENSION = "extension";

	private static final String NODE_AGENT = "user-agent";
	private static final String NODE_ACCEPT = "accept";

	private static final String ATTR_FOLLOW_LINKS = "follow-links";
	private static final String ATTR_PRECOMPILE_ONLY = "precompile-only";
	private static final String ATTR_CONFIRM_EXTENSIONS = "confirm-extensions";
	private static final String NODE_LOAD_CLASS = "load-class";
	private static final String NODE_DEFAULT_FILENAME = "default-filename";

	private static final String NODE_INCLUDE = "include";
	private static final String NODE_EXCLUDE = "exclude";
	private static final String ATTR_INCLUDE_EXCLUDE_PATTERN = "pattern";

	private static final String NODE_INCLUDE_LINKS = "include-links";
	private static final String ATTR_LINK_EXTENSION = "extension";

	private static final String NODE_URI = "uri";
	private static final String ATTR_URI_TYPE = "type";
	private static final String ATTR_URI_SOURCEPREFIX = "src-prefix";
	private static final String ATTR_URI_SOURCEURI = "src";
	private static final String ATTR_URI_DESTURI = "dest";

	private static final String NODE_URIS = "uris";
	private static final String ATTR_NAME = "name";

	public static String configure(Document xconf, CocoonBean cocoon, String destDir, String uriGroup, OutputStreamListener listener)
	throws IllegalArgumentException {

	Node root = xconf.getDocumentElement();
	if (!NODE_ROOT.equals(root.getNodeName())) {
	throw new IllegalArgumentException("Expected root node of "+ NODE_ROOT);
	}

	if (hasAttribute(root, ATTR_VERBOSE)) {
	cocoon.setVerbose(getBooleanAttributeValue(root, ATTR_VERBOSE));
	}
	if (hasAttribute(root, ATTR_FOLLOW_LINKS)) {
	cocoon.setFollowLinks(getBooleanAttributeValue(root, ATTR_FOLLOW_LINKS));
	}
	if (hasAttribute(root, ATTR_PRECOMPILE_ONLY)) {
	cocoon.setPrecompileOnly(getBooleanAttributeValue(root, ATTR_PRECOMPILE_ONLY));
	}
	if (hasAttribute(root, ATTR_CONFIRM_EXTENSIONS)) {
	cocoon.setConfirmExtensions(getBooleanAttributeValue(root, ATTR_CONFIRM_EXTENSIONS));
	}
	if (hasAttribute(root, ATTR_CONTEXT_DIR)) {
	cocoon.setContextDir(getAttributeValue(root, ATTR_CONTEXT_DIR));
	}
	if (hasAttribute(root, ATTR_DEST_DIR)) {
	destDir = getAttributeValue(root, ATTR_DEST_DIR);
	}
	if (hasAttribute(root, ATTR_WORK_DIR)) {
	cocoon.setWorkDir(getAttributeValue(root, ATTR_WORK_DIR));
	}
	if (hasAttribute(root, ATTR_CONFIG_FILE)) {
	cocoon.setConfigFile(getAttributeValue(root, ATTR_CONFIG_FILE));
	}
	if (hasAttribute(root, ATTR_URI_FILE)) {
	cocoon.addTargets(processURIFile(getAttributeValue(root, ATTR_URI_FILE)), destDir);
	}
	if (hasAttribute(root, ATTR_CHECKSUMS_URI)) {
	cocoon.setChecksumURI(getAttributeValue(root, ATTR_CHECKSUMS_URI));
	}
	if (hasAttribute(root, ATTR_AGENT)) {
	cocoon.setAgentOptions(getAttributeValue(root, ATTR_AGENT));
	}
	if (hasAttribute(root, ATTR_ACCEPT)) {
	cocoon.setAcceptOptions(getAttributeValue(root, ATTR_ACCEPT));
	}
	if (hasAttribute(root, ATTR_DEFAULT_FILENAME)) {
	cocoon.setDefaultFilename(getAttributeValue(root, ATTR_DEFAULT_FILENAME));
	}

	if (destDir == null \|\| destDir.length() == 0) {
	destDir = getNodeValue(root, NODE_DEST_DIR);
	}

	NodeList nodes = root.getChildNodes();
	for (int i = 0; i < nodes.getLength(); i++) {
	Node node = nodes.item(i);
	if (node.getNodeType()== Node.ELEMENT_NODE) {
	String nodeName = node.getNodeName();
	if (nodeName.equals(NODE_BROKEN_LINKS)) {
	parseBrokenLinkNode(cocoon, node, listener);

	} else if (nodeName.equals(NODE_LOAD_CLASS)) {
	cocoon.addLoadedClass(getNodeValue(node));

	} else if (nodeName.equals(NODE_LOGGING)) {
	parseLoggingNode(cocoon, node);

	} else if (nodeName.equals(NODE_CONTEXT_DIR)) {
	if (hasAttribute(root, ATTR_CONTEXT_DIR)) {
	throw new IllegalArgumentException("Cannot have "+NODE_CONTEXT_DIR+" as both element and attribute");
	} else {
	cocoon.setContextDir(getNodeValue(node));
	}

	} else if (nodeName.equals(NODE_CONFIG_FILE)) {
	if (hasAttribute(root, ATTR_CONFIG_FILE)) {
	throw new IllegalArgumentException("Cannot have "+NODE_CONFIG_FILE+" as both element and attribute");
	} else {
	cocoon.setConfigFile(getNodeValue(node));
	}
	} else if (nodeName.equals(NODE_DEST_DIR)) {
	// Ignore

	} else if (nodeName.equals(NODE_WORK_DIR)) {
	if (hasAttribute(root, ATTR_WORK_DIR)) {
	throw new IllegalArgumentException("Cannot have "+NODE_WORK_DIR+" as both element and attribute");
	} else {
	cocoon.setWorkDir(getNodeValue(node));
	}
	} else if (nodeName.equals(NODE_CHECKSUMS_URI)) {
	if (hasAttribute(root, ATTR_CHECKSUMS_URI)) {
	throw new IllegalArgumentException("Cannot have "+NODE_CHECKSUMS_URI+" as both element and attribute");
	} else {
	cocoon.setChecksumURI(getNodeValue(node));
	}
	} else if (nodeName.equals(NODE_AGENT)) {
	cocoon.setAgentOptions(getNodeValue(node));

	} else if (nodeName.equals(NODE_ACCEPT)) {
	cocoon.setAcceptOptions(getNodeValue(node));

	} else if (nodeName.equals(NODE_DEFAULT_FILENAME)) {
	cocoon.setDefaultFilename(getNodeValue(node));

	} else if (nodeName.equals(NODE_INCLUDE)) {
	String pattern = parseIncludeExcludeNode(cocoon, node, NODE_INCLUDE);
	cocoon.addIncludePattern(pattern);

	} else if (nodeName.equals(NODE_EXCLUDE)) {
	String pattern = parseIncludeExcludeNode(cocoon, node, NODE_EXCLUDE);
	cocoon.addExcludePattern(pattern);

	} else if (nodeName.equals(NODE_INCLUDE_LINKS)) {
	parseIncludeLinksNode(cocoon, node);

	} else if (nodeName.equals(NODE_URI)) {
	parseURINode(cocoon, node, destDir);

	} else if (nodeName.equals(NODE_URIS)) {
	parseURIsNode(cocoon, node, destDir, uriGroup);

	} else if (nodeName.equals(NODE_URI_FILE)) {
	if (hasAttribute(root, ATTR_URI_FILE)) {
	throw new IllegalArgumentException("Cannot have "+NODE_URI_FILE+" as both element and attribute");
	} else {
	cocoon.addTargets(processURIFile(getNodeValue(node)), destDir);
	}
	} else {
	throw new IllegalArgumentException("Unknown element: <" + nodeName + ">");
	}
	}
	}
	return destDir;
	}

	private static void parseLoggingNode(CocoonBean cocoon, Node node) throws IllegalArgumentException {
	if (hasAttribute(node, ATTR_LOG_KIT)) {
	cocoon.setLogKit(getAttributeValue(node, ATTR_LOG_KIT));
	}
	if (hasAttribute(node, ATTR_LOGGER)) {
	cocoon.setLogger(getAttributeValue(node, ATTR_LOGGER));
	}
	if (hasAttribute(node, ATTR_LOG_LEVEL)) {
	cocoon.setLogLevel(getAttributeValue(node, ATTR_LOG_LEVEL));
	}
	NodeList nodes = node.getChildNodes();
	if (nodes.getLength()!=0) {
	throw new IllegalArgumentException("Unexpected children of <" + NODE_LOGGING + "> node");
	}
	}

	private static void parseIncludeLinksNode(CocoonBean cocoon, Node node) throws IllegalArgumentException {
	if (hasAttribute(node, ATTR_LINK_EXTENSION)) {
	cocoon.addIncludeLinkExtension(getAttributeValue(node, ATTR_LINK_EXTENSION));
	}
	}

	private static void parseBrokenLinkNode(CocoonBean cocoon, Node node, OutputStreamListener listener) throws IllegalArgumentException {
	if (hasAttribute(node, ATTR_BROKEN_LINK_REPORT_FILE)) {
	listener.setReportFile(getAttributeValue(node, ATTR_BROKEN_LINK_REPORT_FILE));
	}
	if (hasAttribute(node, ATTR_BROKEN_LINK_REPORT_TYPE)) {
	listener.setReportType(getAttributeValue(node, ATTR_BROKEN_LINK_REPORT_TYPE));
	}
	if (hasAttribute(node, ATTR_BROKEN_LINK_GENERATE)) {
	cocoon.setBrokenLinkGenerate(getBooleanAttributeValue(node, ATTR_BROKEN_LINK_GENERATE));
	}
	if (hasAttribute(node, ATTR_BROKEN_LINK_EXTENSION)) {
	cocoon.setBrokenLinkExtension(getAttributeValue(node, ATTR_BROKEN_LINK_EXTENSION));
	}
	NodeList nodes = node.getChildNodes();
	if (nodes.getLength()!=0) {
	throw new IllegalArgumentException("Unexpected children of <" + NODE_BROKEN_LINKS + "> node");
	}
	}

	private static String parseIncludeExcludeNode(CocoonBean cocoon, Node node, final String NODE_TYPE) throws IllegalArgumentException {
	NodeList nodes = node.getChildNodes();
	if (nodes.getLength() != 0) {
	throw new IllegalArgumentException("Unexpected children of <" + NODE_INCLUDE + "> node");
	}

	if (hasAttribute(node, ATTR_INCLUDE_EXCLUDE_PATTERN)) {
	return getAttributeValue(node, ATTR_INCLUDE_EXCLUDE_PATTERN);
	} else {
	throw new IllegalArgumentException("Expected a "+ATTR_INCLUDE_EXCLUDE_PATTERN+" attribute for <"+NODE_TYPE+"> node");
	}
	}

	private static void parseURIsNode(CocoonBean cocoon, Node node, String destDir, String uriGroup) throws IllegalArgumentException {

	boolean followLinks = cocoon.followLinks();
	boolean confirmExtensions = cocoon.confirmExtensions();
	String logger = cocoon.getLoggerName();
	String destURI = destDir;
	String root = null;
	String type = null;
	String name = null;

	if (hasAttribute(node, ATTR_FOLLOW_LINKS)) {
	followLinks = getBooleanAttributeValue(node, ATTR_FOLLOW_LINKS);
	}
	if (hasAttribute(node, ATTR_CONFIRM_EXTENSIONS)) {
	confirmExtensions = getBooleanAttributeValue(node, ATTR_CONFIRM_EXTENSIONS);
	}
	if (hasAttribute(node, ATTR_URI_TYPE)) {
	type = getAttributeValue(node, ATTR_URI_TYPE);
	}
	if (hasAttribute(node, ATTR_URI_SOURCEPREFIX)) {
	root = getAttributeValue(node, ATTR_URI_SOURCEPREFIX);
	}
	if (hasAttribute(node, ATTR_URI_DESTURI)) {
	destURI = getAttributeValue(node, ATTR_URI_DESTURI);
	}
	if (hasAttribute(node, ATTR_LOGGER)) {
	logger = getAttributeValue(node, ATTR_LOGGER);
	}
	if (hasAttribute(node, ATTR_NAME)) {
	name = getAttributeValue(node, ATTR_NAME);
	if (name != null && uriGroup != null && !name.equals(uriGroup)) {
	// The user has not selected this URI group, so ignore it.
	return;
	}
	}
	NodeList nodes = node.getChildNodes();
	for (int i = 0; i < nodes.getLength(); i++) {
	Node child = nodes.item(i);
	if (child.getNodeType()== Node.ELEMENT_NODE) {
	String childName = child.getNodeName();
	if (childName.equals(NODE_URI)) {
	String _sourceURI = null;
	String _destURI = destURI;
	String _root = root;
	String _type = type;

	if (child.getAttributes().getLength() == 0) {
	_sourceURI = getNodeValue(child);
	//destURI is inherited
	} else {
	_sourceURI = getAttributeValue(child, ATTR_URI_SOURCEURI);

	if (hasAttribute(child, ATTR_URI_TYPE)) {
	_type = getAttributeValue(child, ATTR_URI_TYPE);
	}
	if (hasAttribute(child, ATTR_URI_SOURCEPREFIX)) {
	_root = getAttributeValue(child, ATTR_URI_SOURCEPREFIX);
	}
	if (hasAttribute(child, ATTR_URI_DESTURI)) {
	_destURI = getAttributeValue(child, ATTR_URI_DESTURI);
	}
	}
	cocoon.addTarget(_type, _root, _sourceURI, _destURI, followLinks, confirmExtensions, logger);
	} else {
	throw new IllegalArgumentException("Unknown element: <" + childName + ">");
	}
	}
	}
	}

	private static void parseURINode(CocoonBean cocoon, Node node, String destDir) throws IllegalArgumentException {
	NodeList nodes = node.getChildNodes();

	if (node.getAttributes().getLength() == 0 && nodes.getLength() != 0) {
	cocoon.addTarget(getNodeValue(node), destDir);
	} else if (node.getAttributes().getLength() !=0 && nodes.getLength() ==0){

	String src = getAttributeValue(node, ATTR_URI_SOURCEURI);

	String type = null;
	if (hasAttribute(node, ATTR_URI_TYPE)) {
	type = getAttributeValue(node, ATTR_URI_TYPE);
	}
	String root = null;
	if (hasAttribute(node, ATTR_URI_SOURCEPREFIX)) {
	root = getAttributeValue(node, ATTR_URI_SOURCEPREFIX);
	}
	String dest = null;
	if (hasAttribute(node, ATTR_URI_DESTURI)) {
	dest = getAttributeValue(node, ATTR_URI_DESTURI);
	}

	if (root != null && type != null && dest != null) {
	cocoon.addTarget(type, root, src, dest);
	} else if (root != null && dest != null) {
	cocoon.addTarget(root, src, dest);
	} else if (dest != null) {
	cocoon.addTarget(src, dest);
	} else {
	cocoon.addTarget(src, destDir);
	}
	} else if (node.getAttributes().getLength() !=0 && nodes.getLength() != 0) {
	throw new IllegalArgumentException("Unexpected children of <" + NODE_URI + "> node");
	} else {
	throw new IllegalArgumentException("Not enough information for <"+ NODE_URI + "> node");
	}
	}

	private static String getNodeValue(Node root, String name) throws IllegalArgumentException {
	NodeList nodes = root.getChildNodes();
	for (int i = 0; i < nodes.getLength(); i++) {
	Node node = nodes.item(i);
	if (node.getNodeType()== Node.ELEMENT_NODE) {
	String nodeName = node.getNodeName();
	if (nodeName.equals(name)) {
	return getNodeValue(node);
	}
	}
	}
	return null;
	}

	private static String getNodeValue(Node node) throws IllegalArgumentException {
	StringBuffer s = new StringBuffer();
	NodeList children = node.getChildNodes();
	boolean found = false;

	for (int i = 0; i < children.getLength(); i++) {
	Node child = children.item(i);
	if (child.getNodeType() == Node.TEXT_NODE) {
	s.append(child.getNodeValue());
	found = true;
	} else {
	throw new IllegalArgumentException("Unexpected node:" + child.getLocalName());
	}
	}
	if (!found) {
	throw new IllegalArgumentException("Expected value for " + node.getLocalName() + " node");
	}
	return s.toString();
	}

	private static String getAttributeValue(Node node, String attr) throws IllegalArgumentException {
	NamedNodeMap nodes = node.getAttributes();
	if (nodes != null) {
	Node attribute = nodes.getNamedItem(attr);
	if (attribute != null && attribute.getNodeValue() != null) {
	return attribute.getNodeValue();
	}
	}
	throw new IllegalArgumentException("Missing " + attr + " attribute on <" + node.getNodeName() + "> node");
	}

	private static boolean hasAttribute(Node node, String attr) {
	NamedNodeMap nodes = node.getAttributes();
	if (nodes != null) {
	Node attribute = nodes.getNamedItem(attr);
	return (attribute != null);
	}
	return false;
	}

	private static boolean getBooleanAttributeValue(Node node, String attr) {
	NamedNodeMap nodes = node.getAttributes();
	if (nodes != null) {
	Node attribute = nodes.getNamedItem(attr);

	if (attribute != null) {
	String value = attribute.getNodeValue();
	return BooleanUtils.toBoolean(value);
	}
	}
	return false;
	}

	/**
	* <code>processURIFile</code> method.
	*
	* @param filename a <code>String</code> value
	* @return uris a <code>List</code> of URIs
	*/
	public static List processURIFile(String filename) {
	List uris = new ArrayList();
	FileReader fr = null;
	BufferedReader uriFile = null;
	try {
	fr = new FileReader(filename);
	uriFile = new BufferedReader(fr);
	String uri;
	while ((uri = uriFile.readLine()) != null) {
	uri = uri.trim();
	if (!uri.equals("") && !uri.startsWith("#")) {
	uris.add(uri.trim());
	}
	}
	} catch (FileNotFoundException e) {
	// nothing to do
	} catch (IOException e) {
	// nothing to do
	} finally {
	IOUtils.closeQuietly(uriFile);
	IOUtils.closeQuietly(fr);
	}
	return uris;
	}
	}