/*
* Copyright 2010 Google 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.google.gwt.validation.rebind;
import com.google.gwt.core.client.GWT;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JArrayType;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JParameterizedType;
import com.google.gwt.core.ext.typeinfo.JRawType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.thirdparty.guava.common.base.Function;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;
import com.google.gwt.validation.client.impl.GwtSpecificValidator;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.validation.Validation;
import javax.validation.ValidationException;
import javax.validation.Validator;
import javax.validation.metadata.BeanDescriptor;
import javax.validation.metadata.PropertyDescriptor;
/**
* <strong>EXPERIMENTAL</strong> and subject to change. Do not use this in
* production code.
* <p>
* A simple struct for the various values associated with a Bean that can be
* validated.
*/
public final class BeanHelper {
public static final Function<BeanHelper, Class<?>> TO_CLAZZ =
new Function<BeanHelper, Class<?>>() {
public Class<?> apply(BeanHelper helper) {
return helper.getClazz();
}
};
private static final Validator serverSideValidator =
Validation.buildDefaultValidatorFactory().getValidator();
// stash the map in a ThreadLocal, since each GWT module lives in its own
// thread in DevMode
private static final ThreadLocal<Map<JClassType, BeanHelper>> threadLocalHelperMap =
new ThreadLocal<Map<JClassType, BeanHelper>>() {
@Override
protected synchronized Map<JClassType, BeanHelper> initialValue() {
return new HashMap<JClassType, BeanHelper>();
}
};
/**
* Visible for testing.
*/
public static void clearBeanHelpersForTests() {
threadLocalHelperMap.get().clear();
}
public static BeanHelper createBeanHelper(Class<?> clazz, TreeLogger logger,
GeneratorContext context) throws UnableToCompleteException {
JClassType beanType = context.getTypeOracle().findType(
clazz.getCanonicalName());
return createBeanHelper(clazz, beanType, logger, context);
}
public static Map<JClassType, BeanHelper> getBeanHelpers() {
return Collections.unmodifiableMap(threadLocalHelperMap.get());
}
protected static BeanHelper createBeanHelper(JClassType jType,
TreeLogger logger, GeneratorContext context)
throws UnableToCompleteException {
JClassType erasedType = jType.getErasedType();
try {
Class<?> clazz = Class.forName(erasedType.getQualifiedBinaryName());
return createBeanHelper(clazz, erasedType, logger, context);
} catch (ClassNotFoundException e) {
logger.log(TreeLogger.ERROR, "Unable to create BeanHelper for "
+ erasedType, e);
throw new UnableToCompleteException();
}
}
protected static boolean isClassConstrained(Class<?> clazz) {
return serverSideValidator.getConstraintsForClass(clazz).isBeanConstrained();
}
static BeanHelper getBeanHelper(JClassType beanType) {
return getBeanHelpers().get(beanType.getErasedType());
}
/**
* Write an Empty Interface implementing {@link GwtSpecificValidator} with
* Generic parameter of the bean type.
*/
static void writeInterface(GeneratorContext context, TreeLogger logger,
BeanHelper bean) {
PrintWriter pw = context.tryCreate(logger, bean.getPackage(),
bean.getValidatorName());
if (pw != null) {
TreeLogger interfaceLogger = logger.branch(TreeLogger.TRACE,
"Creating the interface for " + bean.getFullyQualifiedValidatorName());
ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(
bean.getPackage(), bean.getValidatorName());
factory.addImplementedInterface(GwtSpecificValidator.class.getCanonicalName()
+ " <" + bean.getTypeCanonicalName() + ">");
factory.addImport(GWT.class.getCanonicalName());
factory.makeInterface();
SourceWriter sw = factory.createSourceWriter(context, pw);
// static MyValidator INSTANCE = GWT.create(MyValidator.class);
sw.print("static ");
sw.print(bean.getValidatorName());
sw.print(" INSTANCE = GWT.create(");
sw.print(bean.getValidatorName());
sw.println(".class);");
sw.commit(interfaceLogger);
pw.close();
}
}
private static synchronized void addBeanHelper(BeanHelper helper) {
threadLocalHelperMap.get().put(helper.getJClass(), helper);
}
private static BeanHelper createBeanHelper(Class<?> clazz,
JClassType beanType, TreeLogger logger, GeneratorContext context)
throws UnableToCompleteException {
BeanHelper helper = getBeanHelper(beanType);
if (helper == null) {
BeanDescriptor bean;
try {
bean = serverSideValidator.getConstraintsForClass(clazz);
} catch (ValidationException e) {
logger.log(TreeLogger.ERROR,
"Unable to create a validator for " + clazz.getCanonicalName()
+ " because " + e.getMessage(), e);
throw new UnableToCompleteException();
}
helper = new BeanHelper(beanType, clazz, bean);
addBeanHelper(helper);
writeInterface(context, logger, helper);
// now recurse on all Cascaded elements
for (PropertyDescriptor p : bean.getConstrainedProperties()) {
if (p.isCascaded()) {
createBeanHelper(p, helper, logger, context);
}
}
}
return helper;
}
private static void createBeanHelper(PropertyDescriptor p, BeanHelper parent,
TreeLogger logger, GeneratorContext context)
throws UnableToCompleteException {
Class<?> elementClass = p.getElementClass();
if (GwtSpecificValidatorCreator.isIterableOrMap(elementClass)) {
if (parent.hasField(p)) {
JClassType type = parent.getAssociationType(p, true);
createBeanHelper(type.getErasedType(), logger, context);
}
if (parent.hasGetter(p)) {
JClassType type = parent.getAssociationType(p, false);
createBeanHelper(type.getErasedType(), logger, context);
}
} else {
if (serverSideValidator.getConstraintsForClass(elementClass).isBeanConstrained()) {
createBeanHelper(elementClass, logger, context);
}
}
}
private final BeanDescriptor beanDescriptor;
private final JClassType jClass;
private Class<?> clazz;
private BeanHelper(JClassType jClass, Class<?> clazz,
BeanDescriptor beanDescriptor) {
super();
this.beanDescriptor = beanDescriptor;
this.jClass = jClass;
this.clazz = clazz;
}
public JClassType getAssociationType(PropertyDescriptor p, boolean useField) {
JType type = this.getElementType(p, useField);
JArrayType jArray = type.isArray();
if (jArray != null) {
return jArray.getComponentType().isClassOrInterface();
}
JParameterizedType pType = type.isParameterized();
JClassType[] typeArgs;
if (pType == null) {
JRawType rType = type.isRawType();
typeArgs = rType.getGenericType().getTypeParameters();
} else {
typeArgs = pType.getTypeArgs();
}
// it is either a Iterable or a Map use the last type arg.
return typeArgs[typeArgs.length - 1].isClassOrInterface();
}
public BeanDescriptor getBeanDescriptor() {
return beanDescriptor;
}
/*
* The server side validator needs an actual class.
*/
public Class<?> getClazz() {
return clazz;
}
public String getDescriptorName() {
return jClass.getName() + "Descriptor";
}
public String getFullyQualifiedValidatorName() {
return getPackage() + "." + getValidatorName();
}
public JClassType getJClass() {
return jClass;
}
public String getPackage() {
return jClass.getPackage().getName();
}
public String getTypeCanonicalName() {
return jClass.getQualifiedSourceName();
}
public String getValidatorInstanceName() {
return getFullyQualifiedValidatorName() + ".INSTANCE";
}
public String getValidatorName() {
return makeJavaSafe("_" + jClass.getName() + "Validator");
}
@Override
public String toString() {
return getTypeCanonicalName();
}
JType getElementType(PropertyDescriptor p, boolean useField) {
if (useField) {
return jClass.findField(p.getPropertyName()).getType();
} else {
return jClass.findMethod(GwtSpecificValidatorCreator.asGetter(p),
GwtSpecificValidatorCreator.NO_ARGS).getReturnType();
}
}
boolean hasField(PropertyDescriptor p) {
JField field = jClass.findField(p.getPropertyName());
return field != null;
}
boolean hasGetter(PropertyDescriptor p) {
JType[] paramTypes = new JType[]{};
try {
jClass.getMethod(GwtSpecificValidatorCreator.asGetter(p), paramTypes);
return true;
} catch (NotFoundException e) {
return false;
}
}
private String makeJavaSafe(String in) {
return in.replaceAll("\\.", "_");
}
}