2009/05/20 - Apache Shale has been retired.

 /*

  * 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.shale.clay.utils;

 import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.InputStreamReader;

 import java.net.URL;

 import java.util.ArrayList;

 import java.util.Enumeration;

 import java.util.Iterator;

 import java.util.List;

 import java.util.StringTokenizer;

 import javax.faces.webapp.UIComponentTag;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.apache.shale.clay.config.beans.AttributeBean;

 import org.apache.shale.clay.config.beans.ComponentBean;

 import org.apache.shale.clay.parser.Node;

 import org.apache.shale.clay.parser.Parser;

 import org.apache.shale.util.Messages;

 /**

  * <p>Rips through JSP Tag Library Descriptors converting them into Clay configuration beans.</p>

  */

 public class TldDigester {

     /**

      * <p>

      * Commons logger utility class instance.

      * </p>

      */

     private static Log log;

     static {

         log = LogFactory.getLog(TldDigester.class);

     }

     /**

      * <p>

      * Message resources for this class.

      * </p>

      */

     private static Messages messages = new Messages(

             "org.apache.shale.clay.Bundle", TldDigester.class.getClassLoader());

     /**

      * <p>Returns an array of <code>URL</code>'s that represent the

      * target TLD documents.  The parameter <code>tldResources</code>

      * is a comma delimited value list of tld documents.</p>

      *

      * @param tldResources paths to the TLD's within the jars

      * @return array of TLD URL's

      * @throws IOException  error locating the resource

      */

     private URL[] findUrls(String tldResources) throws IOException {

         StringTokenizer tokenizer = new StringTokenizer(tldResources, ", ");

         List tmp = new ArrayList();

         ClassLoader classloader = Thread.currentThread().getContextClassLoader();

         if (classloader == null) {

             classloader = this.getClass().getClassLoader();

         }

         while (tokenizer.hasMoreTokens()) {

             String tldResource = tokenizer.nextToken().trim();

             if (tldResources.length() == 0) {

                continue;

             }

             for (Enumeration ui = classloader.getResources(tldResource); ui.hasMoreElements();) {

                 URL url = (URL) ui.nextElement();

                 if (url != null) {

                     tmp.add(url);

                 }

             }

         }

         URL[] urls = new URL[tmp.size()];

         tmp.toArray(urls);

         return urls;

     }

     /**

      * <p>Loads the <code>targetURL</code> into a <code>StringBuffer</code>.</p>

      * @param targetURL TLD document

      * @return content of the TLD document

      * @throws IOException error reading template

      */

     private StringBuffer load(URL targetURL) throws IOException {

         StringBuffer buff = new StringBuffer();

         BufferedReader in = null;

         try {

             in = new BufferedReader(new InputStreamReader(targetURL.openStream()));

             while (in.ready()) {

                buff.append(in.readLine());

             }

         } finally {

            if (in != null) {

               in.close();

            }

         }

         return buff;

     }

     /**

      * <p>Parsers the TLD document using the clay markup parser.</p>

      * @param document TLD

      * @return root <code>taglib</code> document node.

      */

     private Node parse(StringBuffer document) {

        Parser parser = new Parser();

        List roots = parser.parse(document);

        for (Iterator ri = roots.iterator(); ri.hasNext();) {

           Node node = (Node) ri.next();

           if (node.isWellFormed() && node.getName().equals("taglib")) {

              return node;

           }

        }

        return null;

     }

     /**

      * <p>Finds a node with a matching <code>name</code>

      * starting at the <code>root</code>.</p>

      *

      * @param root starting node

      * @param name target node name

      * @return sibling node with a matching name

      */

     private Node findNode(Node root, String name) {

         List nodes = root.getNodesByName(name);

         if (nodes.size() > 0) {

            return (Node) nodes.get(0);

         }

         return null;

     }

     /**

      * <p>Returns the node's text value.</p>

      * @param root starting node

      * @param name target node name

      * @return text of the node between the starting and ending nodes

      */

     private String getValue(Node root, String name) {

         String value = null;

         Node node = findNode(root, name);

         if (node == null) {

             return null;

         }

         for (Iterator ni = node.getChildren().iterator(); ni.hasNext();) {

             Node child = (Node) node.getChildren().get(0);

             if (!child.isWellFormed() && !isNodeWhitespace(child)) {

                 value = child.getToken().getRawText();

                 break;

             }

         }

         return value;

     }

     /**

      * <p>Test the value of the node and returns <code>true</code> if

      * the value is only whitespace.</p>

      *

      * @param node markup node

      * @return <code>true</code> if value of the node is only whitespace

      */

     private boolean isNodeWhitespace(Node node) {

         StringBuffer document = node.getToken().getDocument();

         for (int i = node.getToken().getBeginOffset();

              i < node.getToken().getEndOffset(); i++) {

            char c = document.charAt(i);

            if (!Character.isWhitespace(c)) {

                return false;

            }

         }

         return true;

     }

     /**

      * <p>Creates an {@link AttributeBean} from a markup {@link Node}.</p>

      * @param node markup node

      * @return attribute config bean

      */

     private AttributeBean createAttributeConfig(Node node) {

         String name = getValue(node, "name");

         if (name.equals("jsfid")) {

             return null;

         }

         AttributeBean bean = new AttributeBean();

         bean.setName(name);

         if (name.startsWith("action")

                || (name.indexOf("validator") > -1)

                || (name.indexOf("Validator") > -1)

                || name.equals("valueChangeListener")) {

             bean.setBindingType(AttributeBean.BINDING_TYPE_METHOD);

         } else {

             bean.setBindingType(AttributeBean.BINDING_TYPE_VALUE);

         }

         //bean.setDescription(getValue(node, "description"));

         return bean;

     }

     /**

      * <p>Creates a {@link ComponentBean} from a markup {@link Node}.

      * Adds all child "attribute" {@link Node}s as {@link ComponentBean}

      * {@link AttributeBean}s.</p>

      *

      * @param node markup node

      * @param prefix namespace prefix

      * @return config bean that represents the TLD tag

      */

     private ComponentBean createComponentConfig(Node node, String prefix) {

         StringBuffer name = new StringBuffer(prefix);

         name.append(":").append(getValue(node, "name"));

         String tagClazz = getValue(node, "tag-class");

         UIComponentTag tag = null;

         try {

             Class clazz = Class.forName(tagClazz);

             Object t = clazz.newInstance();

             if (t instanceof UIComponentTag) {

                 tag = (UIComponentTag) t;

             }

         } catch (ClassNotFoundException e) {

             log.error(messages.getMessage("tag.load.error",

                     new Object[] {name.toString(), tagClazz}), e);

             return null;

         } catch (InstantiationException e) {

             log.error(messages.getMessage("tag.load.error",

                     new Object[] {name.toString(), tagClazz}), e);

             return null;

         } catch (IllegalAccessException e) {

             log.error(messages.getMessage("tag.load.error",

                     new Object[] {name.toString(), tagClazz}), e);

             return null;

         }

         if (tag == null) {

             log.error(messages.getMessage("tag.load.error",

                     new Object[] {name.toString(), tagClazz}));

             return null;

         }

         ComponentBean bean = new ComponentBean();

         bean.setJsfid(name.toString());

         bean.setComponentType(tag.getComponentType());

         //bean.setDescription(getValue(node, "description"));

         List attributes = node.getNodesByName("attribute");

         for (Iterator ai = attributes.iterator(); ai.hasNext();) {

             Node attrNode = (Node) ai.next();

             AttributeBean attr = createAttributeConfig(attrNode);

             if (attr != null) {

                 bean.addAttribute(attr);

             }

         }

         return bean;

     }

     /**

      * <p>Converts the TLD into an array of {@link ComponentBean}

      * starting at the "taglib" root node.  Each "tag" will be

      * converted into a {@link Clay} configuration bean.</p>

      *

      * @param root TLD taglib root node

      * @return Clay config beans that acts as a stand-in for the TLD

      */

     private ComponentBean[] convert(Node root) {

         List beans = new ArrayList();

         String shortName = getValue(root, "short-name");

         List tags = root.getNodesByName("tag");

         for (Iterator ti = tags.iterator(); ti.hasNext();) {

             Node node = (Node) ti.next();

             ComponentBean bean = createComponentConfig(node, shortName);

             if (bean != null) {

                beans.add(bean);

             }

         }

         ComponentBean[] configBeans = new ComponentBean[beans.size()];

         beans.toArray(configBeans);

         return configBeans;

     }

     /**

      * <p>Converts TLD files located in jars into {@link Clay}'s

      * metadata.  The tag handlers are loaded and the

      * <code>componentType</code> extracted.</p>

      *

      * @param tldResources comma separated list of tag library descriptors.

      *        The fully qualified class path is required.

      * @return array of config beans

      * @throws IOException error loading the tld file

      */

     public TldDefinition[] digest(String tldResources) throws IOException {

         List defs = new ArrayList();

         URL[] urls = findUrls(tldResources);

         StringBuffer document = null;

         for (int i = 0; i < urls.length; i++) {

             document = load(urls[i]);

             Node root = parse(document);

             defs.add(createTldDefinition(root, convert(root)));

             document.setLength(0);

         }

         TldDefinition[] configDefs = new TldDefinition[defs.size()];

         defs.toArray(configDefs);

         return configDefs;

     }

     /**

      * <p>Factory method that creates a structure to hold information

      * about the tag library descriptor.</p>

      *

      * @param root TLD document root

      * @param configBeans POJO beans describing the tag handler information

      * @return a structure representing the TLD

      */

     private TldDefinition createTldDefinition(final Node root, final ComponentBean[] configBeans) {

        final String uri = getValue(root, "uri");

        final String shortname = getValue(root, "short-name");

        final String tlibVersion = getValue(root, "tlib-version");

        final String jspVersion = getValue(root, "jsp-version");

        return new TldDefinition() {

            public ComponentBean[] getConfigBeans() {

                return configBeans;

            }

            public String getUri() {

               return uri;

            }

            public String getShortname() {

                return shortname;

            }

            public String getTlibVersion() {

                return tlibVersion;

            }

            public String getJspVersion() {

                return jspVersion;

            }

        };

     }

     /**

      * <p>Top-level interfaces that describes a TLD.</p>

      */

     public static interface TldDefinition {

        /**

         * @return Configuration beans that describe the attributes of the component

         */

        ComponentBean[] getConfigBeans();

        /**

         * @return the TLD's uri

         */

        String getUri();

        /**

         * @return the TLD's short name

         */

        String getShortname();

        /**

         * @return tag library version

         */

        String getTlibVersion();

        /**

         * @return JavaServer Pages version

         */

        String getJspVersion();

     }

 }