tapestry-javadoc/src/main/java/org/apache/tapestry5/javadoc/ClassDescription.java

// Copyright 2007, 2009, 2011 The Apache Software Foundation
//
// Licensed 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.tapestry5.javadoc;

import java.util.Map;

import org.apache.tapestry5.BindingConstants;
import org.apache.tapestry5.annotations.Component;
import org.apache.tapestry5.annotations.Events;
import org.apache.tapestry5.annotations.Parameter;
import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
import org.apache.tapestry5.ioc.internal.util.InternalUtils;

import com.sun.javadoc.AnnotationDesc;
import com.sun.javadoc.AnnotationDesc.ElementValuePair;
import com.sun.javadoc.AnnotationValue;
import com.sun.javadoc.ClassDoc;
import com.sun.javadoc.Doc;
import com.sun.javadoc.FieldDoc;
import com.sun.javadoc.ProgramElementDoc;
import com.sun.javadoc.Tag;

public class ClassDescription
{
    public final ClassDoc classDoc;

    public final Map<String, ParameterDescription> parameters = CollectionFactory.newCaseInsensitiveMap();

    /**
     * Case insensitive map, keyed on event name, value is optional description (often blank).
     */
    public final Map<String, String> events = CollectionFactory.newCaseInsensitiveMap();

    public ClassDescription()
    {
        this.classDoc = null;
    }

    public ClassDescription(ClassDoc classDoc, ClassDescriptionSource source)
    {
        this.classDoc = classDoc;

        loadEvents();
        loadParameters(source);

        ClassDoc parentDoc = classDoc.superclass();

        if (parentDoc != null)
        {
            ClassDescription parentDescription = source.getDescription(classDoc.superclass().qualifiedName());

            mergeInto(events, parentDescription.events);
            mergeInto(parameters, parentDescription.parameters);
        }
    }

    private void loadEvents()
    {
        AnnotationDesc eventsAnnotation = getAnnotation(classDoc, Events.class);

        if (eventsAnnotation == null)
            return;

        // Events has only a single attribute: value(), so we know its the first element
        // in the array.

        ElementValuePair pair = eventsAnnotation.elementValues()[0];

        AnnotationValue annotationValue = pair.value();
        AnnotationValue[] values = (AnnotationValue[]) annotationValue.value();

        for (AnnotationValue eventValue : values)
        {
            String event = (String) eventValue.value();
            int ws = event.indexOf(' ');

            String name = ws < 0 ? event : event.substring(0, ws);
            String description = ws < 0 ? "" : event.substring(ws + 1).trim();

            events.put(name, description);
        }
    }

    private static <K, V> void mergeInto(Map<K, V> target, Map<K, V> source)
    {
        for (K key : source.keySet())
        {
            if (!target.containsKey(key))
            {
                V value = source.get(key);
                target.put(key, value);
            }
        }
    }

    private void loadParameters(ClassDescriptionSource source)
    {
        for (FieldDoc fd : classDoc.fields(false))
        {
            if (fd.isStatic())
                continue;

            if (!fd.isPrivate())
                continue;

            Map<String, String> values = getAnnotationValues(fd, Parameter.class);

            if (values != null)
            {
                String name = values.get("name");

                if (name == null)
                    name = fd.name().replaceAll("^[$_]*", "");

                ParameterDescription pd = new ParameterDescription(fd, name, fd.type().qualifiedTypeName(), get(values,
                        "value", ""), get(values, "defaultPrefix", BindingConstants.PROP), getBoolean(values,
                        "required", false), getBoolean(values, "allowNull", true), getBoolean(values, "cache", true),
                        getSinceTagValue(fd), isDeprecated(fd));

                parameters.put(name, pd);

                continue;
            }

            values = getAnnotationValues(fd, Component.class);

            if (values != null)
            {
                String names = get(values, "publishParameters", "");

                if (InternalUtils.isBlank(names))
                    continue;

                for (String name : names.split("\\s*,\\s*"))
                {
                    ParameterDescription pd = getPublishedParameterDescription(source, fd, name);
                    parameters.put(name, pd);
                }

            }

        }
    }

    private ParameterDescription getPublishedParameterDescription(ClassDescriptionSource source, FieldDoc fd,
            String name)
    {
        String currentClassName = fd.type().qualifiedTypeName();

        while (true)
        {
            ClassDescription componentCD = source.getDescription(currentClassName);

            if (componentCD.classDoc == null)
                throw new IllegalArgumentException(String.format("Published parameter '%s' from %s not found.", name,
                        fd.qualifiedName()));

            if (componentCD.parameters.containsKey(name)) { return componentCD.parameters.get(name); }

            currentClassName = componentCD.classDoc.superclass().typeName();
        }
    }

    private static boolean isDeprecated(ProgramElementDoc doc)
    {
        return (getAnnotation(doc, Deprecated.class) != null) || (doc.tags("deprecated").length != 0);
    }

    private static String getSinceTagValue(Doc doc)
    {
        return getTagValue(doc, "since");
    }

    private static String getTagValue(Doc doc, String tagName)
    {
        Tag[] tags = doc.tags(tagName);

        return 0 < tags.length ? tags[0].text() : "";
    }

    private static boolean getBoolean(Map<String, String> map, String key, boolean defaultValue)
    {
        if (map.containsKey(key))
            return Boolean.parseBoolean(map.get(key));

        return defaultValue;
    }

    private static String get(Map<String, String> map, String key, String defaultValue)
    {
        if (map.containsKey(key))
            return map.get(key);

        return defaultValue;
    }

    private static AnnotationDesc getAnnotation(ProgramElementDoc source, Class annotationType)
    {
        String name = annotationType.getName();

        for (AnnotationDesc ad : source.annotations())
        {
            if (ad.annotationType().qualifiedTypeName().equals(name)) { return ad; }
        }

        return null;
    }

    private static Map<String, String> getAnnotationValues(ProgramElementDoc source, Class annotationType)
    {
        AnnotationDesc annotation = getAnnotation(source, annotationType);

        if (annotation == null)
            return null;

        Map<String, String> result = CollectionFactory.newMap();

        for (ElementValuePair pair : annotation.elementValues())
        {
            result.put(pair.element().name(), pair.value().value().toString());
        }

        return result;
    }
}