GenProxyProcessor.java

/*
 * Copyright 2011 ArcBees Inc.
 *
 * 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 com.gwtplatform.dispatch.annotation.processor;

import java.io.IOException;
import java.io.Writer;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.MirroredTypeException;
import javax.lang.model.type.TypeMirror;

import com.google.web.bindery.requestfactory.shared.Locator;
import com.gwtplatform.dispatch.annotation.GenProxy;
import com.gwtplatform.dispatch.annotation.UseProxy;
import com.gwtplatform.dispatch.annotation.UseProxyName;
import com.gwtplatform.dispatch.annotation.helper.InterfaceGenerationHelper;
import com.gwtplatform.dispatch.annotation.helper.ReflectionHelper;

/**
 * Processes {@link GenProxy} annotations.
 * <p/>
 * {@link GenProxyProcessor} should only ever be called by tool infrastructure.
 * See {@link javax.annotation.processing.Processor} for more details.
 */
@SupportedAnnotationTypes("com.gwtplatform.dispatch.annotation.GenProxy")
public class GenProxyProcessor extends GenProcessor {
    @Override
    public void process(final Element proxyElement) {
        GenProxy genProxy = proxyElement.getAnnotation(GenProxy.class);
        generateProxy(
                proxyElement,
                genProxy.targetPackage(),
                genProxy.filterSetter(),
                genProxy.filterGetter(),
                genProxy.isEmbeddedType(),
                getLocatorTypeMirror(genProxy)
        );
    }

    protected void generateProxy(Element proxyElement, String targetPackage, String[] filterSetter,
            String[] filterGetter, boolean isEmbeddedType, TypeMirror locatorType) {
        InterfaceGenerationHelper writer = null;
        try {
            ReflectionHelper reflection = new ReflectionHelper(getEnvironment(), (TypeElement) proxyElement);
            String proxyElementSimpleName = reflection.getSimpleClassName();
            String proxyElementClassName = reflection.getClassName();
            String proxyElementPackage = reflection.getPackageName();

            // Magic: By default proxies should be available for client and server side.
            String preparedProxyElementClassName = proxyElementClassName.replace(".server", ".shared");
            String preparedProxyElementPackage = proxyElementPackage.replace(".server", ".shared");

            if (targetPackage != null && !targetPackage.isEmpty()) {
                // Prepare user defined proxy target package and do not replace server with shared.
                preparedProxyElementClassName = targetPackage + "." + proxyElementSimpleName;
                preparedProxyElementPackage = targetPackage;
            }

            String proxySimpleName = proxyElementSimpleName + "Proxy";
            String proxyClassName = preparedProxyElementClassName + "Proxy";

            @SuppressWarnings("resource")
            Writer sourceWriter = getEnvironment().getFiler().createSourceFile(proxyClassName,
                    proxyElement).openWriter();
            writer = new InterfaceGenerationHelper(sourceWriter);
            writer.generatePackageDeclaration(preparedProxyElementPackage);

            if (isEmbeddedType) {
                generateValueProxyHeader(writer, reflection, proxyElementClassName, proxySimpleName);
            } else {
                generateEntityProxyHeader(writer, reflection, proxyElementClassName, proxySimpleName, locatorType);
            }

            writer.println();

            Collection<VariableElement> allFields = reflection.getNonConstantFields();

            // Generate getters.
            Collection<VariableElement> getterFields = reflection.filterFields(allFields, filterGetter);
            for (VariableElement getterField : getterFields) {
                generateGetter(writer, getterField);
            }

            // Generate setters.
            Collection<VariableElement> setterFields = reflection.filterFields(allFields, filterSetter);
            for (VariableElement setterField : setterFields) {
                generateSetter(writer, setterField);
            }

            writer.println();
            writer.generateFooter();
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (writer != null) {
                writer.close();
            }
        }
    }

    protected void generateEntityProxyHeader(InterfaceGenerationHelper writer, ReflectionHelper reflection,
            String proxyElementClassName, String proxySimpleName, TypeMirror locatorType) {
        writer.generateImports(
                "com.google.web.bindery.requestfactory.shared.ProxyFor",
                "com.google.web.bindery.requestfactory.shared.EntityProxy",
                "com.google.web.bindery.requestfactory.shared.EntityProxyId"
        );
        writer.println();
        // Check for locator.
        if (locatorType == null || Locator.class.getName().equals(locatorType.toString())) {
            writer.generateAnnotation("ProxyFor", proxyElementClassName + ".class");
        } else {
            writer.println("@{0}(value = {1}.class, locator = {2}.class)",
                    "ProxyFor", proxyElementClassName,
                    locatorType.toString());
        }
        writer.generateInterfaceHeader(proxySimpleName, reflection.getClassRepresenter().getModifiers(),
                "EntityProxy"
        );
        writer.println();
        writer.generateEmptyMethodBody("stableId", "EntityProxyId<" + proxySimpleName + ">");
    }

    protected void generateValueProxyHeader(InterfaceGenerationHelper writer, ReflectionHelper reflection,
            String proxyElementClassName, String proxySimpleName) {
        writer.generateImports(
                "com.google.web.bindery.requestfactory.shared.ProxyFor",
                "com.google.web.bindery.requestfactory.shared.ValueProxy"
        );
        writer.println();
        writer.generateAnnotation("ProxyFor", proxyElementClassName + ".class");
        writer.generateInterfaceHeader(proxySimpleName, reflection.getClassRepresenter().getModifiers(), "ValueProxy");
    }

    protected void generateGetter(InterfaceGenerationHelper writer, VariableElement getterField) {
        // Check for embedded types.
        UseProxy useProxyAnnotation = getterField.getAnnotation(UseProxy.class);
        UseProxyName useProxyNameAnnotation = getterField.getAnnotation(UseProxyName.class);
        if (useProxyAnnotation != null) {
            writer.generateGetter(getterField.getSimpleName().toString(), getProxyTypeMirrorName(useProxyAnnotation,
                    getterField.asType()));
        } else if (useProxyNameAnnotation != null) {
            writer.generateGetter(getterField.getSimpleName().toString(), useProxyNameAnnotation.value());
        } else {
            writer.generateGetter(getterField);
        }
    }

    protected void generateSetter(InterfaceGenerationHelper writer, VariableElement setterField) {
        // Check for embedded types.
        UseProxy useProxyAnnotation = setterField.getAnnotation(UseProxy.class);
        UseProxyName useProxyNameAnnotation = setterField.getAnnotation(UseProxyName.class);
        if (useProxyAnnotation != null) {
            writer.generateSetter(setterField.getSimpleName().toString(), getProxyTypeMirrorName(useProxyAnnotation,
                    setterField.asType()));
        } else if (useProxyNameAnnotation != null) {
            writer.generateSetter(setterField.getSimpleName().toString(), useProxyNameAnnotation.value());
        } else {
            writer.generateSetter(setterField);
        }
    }

    /**
     * Workaround for MirroredTypeException (Attempt to access Class object for TypeMirror).
     *
     * @see <a href="http://goo.gl/7ee2R">Getting class values from annotations in an annotationprocessor</a>
     */
    protected final String getProxyTypeMirrorName(UseProxy useProxyAnnotation, TypeMirror originalTypeMirror) {
        TypeMirror mirror = null;
        try {
            useProxyAnnotation.value();
        } catch (MirroredTypeException e) {
            mirror = e.getTypeMirror();
        }

        return nestIntoCollectionIfNecessary(mirror, originalTypeMirror);
    }

    private String nestIntoCollectionIfNecessary(TypeMirror mirror, TypeMirror originalTypeMirror) {
        String originalTypeDeclaration = originalTypeMirror.toString();

        // Shortcut if no generics can be found in the type declaration
        if (!(originalTypeDeclaration.contains("<") && originalTypeDeclaration.contains(">"))) {
            return mirror.toString();
        }

        String collectionClassName = originalTypeDeclaration.substring(0, originalTypeDeclaration.indexOf("<"));
        Class collectionClass = tryRetrieveCollectionClass(collectionClassName);

        StringBuilder builder = new StringBuilder();
        if (collectionClass != null && (isAssignableToSet(collectionClass) || isAssignableToList(collectionClass))) {
            builder.append(collectionClassName).append("<").append(mirror.toString()).append(">");
        } else {
            builder.append(mirror.toString());
        }
        return builder.toString();
    }

    private Class tryRetrieveCollectionClass(String collectionClassName) {
        try {
            return Class.forName(collectionClassName);
        } catch (ClassNotFoundException e) {
            printMessage("Potential collection class " + collectionClassName + " could not be found.");
        }
        return null;
    }

    private boolean isAssignableToSet(Class collectionClass) {
        if (collectionClass.equals(Set.class)) {
            return true;
        }
        for (Class interfaceClass : collectionClass.getInterfaces()) {
            if (interfaceClass.equals(Set.class)) {
                return true;
            }
        }
        return false;
    }

    private boolean isAssignableToList(Class collectionClass) {
        if (collectionClass.equals(List.class)) {
            return true;
        }
        for (Class interfaceClass : collectionClass.getInterfaces()) {
            if (interfaceClass.equals(List.class)) {
                return true;
            }
        }
        return false;
    }

    /**
     * @see #getProxyTypeMirrorName(com.gwtplatform.dispatch.annotation.UseProxy, javax.lang.model.type.TypeMirror)
     */
    protected final TypeMirror getLocatorTypeMirror(GenProxy genProxyAnnotation) {
        TypeMirror mirror = null;
        try {
            genProxyAnnotation.locator();
        } catch (MirroredTypeException e) {
            mirror = e.getTypeMirror();
        }
        return mirror;
    }
}