This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository eugene. See http://git.nuiton.org/eugene.git commit f4438f43977a53d228c7ea73651a101290c9c417 Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Aug 15 10:10:41 2015 +0200 By default, we should always generate abstract classes. Add a tag value overrideAbstractClasses to let use override this default behaviour. If an abstract class is found in class-path, the generation will failed. See #3747 --- .../eugene/java/AbstractJavaBeanTransformer.java | 27 +++ .../nuiton/eugene/java/JavaBeanTransformer.java | 10 +- .../nuiton/eugene/java/JavaTemplatesTagValues.java | 40 ++++- .../eugene/java/SimpleJavaBeanTransformer.java | 193 +++++++++++---------- .../SimpleJavaBeanWithNoInterfaceTransformer.java | 2 +- 5 files changed, 169 insertions(+), 103 deletions(-) diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java index 4f35699..cb268dc 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java @@ -27,6 +27,8 @@ package org.nuiton.eugene.java; /*{generator option: writeString = +}*/ import org.apache.commons.lang3.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; import org.nuiton.eugene.EugeneTagValues; import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.models.object.ObjectModelAttribute; @@ -55,6 +57,9 @@ import java.util.Set; */ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformerToJava { + /** Logger. */ + private static final Log log = LogFactory.getLog(AbstractJavaBeanTransformer.class); + private JavaTemplatesTagValues javaTemplatesTagValues; public JavaTemplatesTagValues getJavaTemplatesTagValues() { @@ -831,4 +836,26 @@ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformer return sb.toString(); } + protected boolean canGenerateAbstractClass(ObjectModelPackage aPackage, ObjectModelClass aclass, String abstractClassName) { + + boolean notInClassPath = notFoundInClassPath(aclass, abstractClassName); + + if (!notInClassPath) { + + boolean canOverride = getJavaTemplatesTagValues().isOverrideAbstractClasses(aclass, aPackage, model); + String fqn = aclass.getPackageName() + "." + abstractClassName; + if (!canOverride) { + String message = "Can not override abstract class " + fqn + ", already found in classpath"; + message += "\nTo authorize it, add a tag value *overrideAbstractClasses* or model, package or class."; + throw new IllegalStateException(message); + } + if (log.isWarnEnabled()) { + log.warn("Will not generate abstract class: " + fqn); + } + } + + return notInClassPath; + + } + } diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaBeanTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaBeanTransformer.java index 8b143e3..32f4b42 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaBeanTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaBeanTransformer.java @@ -63,7 +63,7 @@ public class JavaBeanTransformer extends AbstractJavaBeanTransformer { ObjectModelClass output = null; - if (canGenerateAbstract(input)) { + if (canGenerateAbstractClass(aPackage, input, input.getName())) { // nothing more to do output = generateAbstract(aPackage, input); @@ -75,10 +75,10 @@ public class JavaBeanTransformer extends AbstractJavaBeanTransformer { } } - protected boolean canGenerateAbstract(ObjectModelClass input) { - boolean b = !isInClassPath(input); - return b; - } +// protected boolean canGenerateAbstract(ObjectModelClass input) { +// boolean b = !isInClassPath(input); +// return b; +// } protected boolean canGenerateImpl(ObjectModelClass input, ObjectModelClass abstractOutput) { diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java index cf8b1e9..e2d431a 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java @@ -39,6 +39,22 @@ import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProvider; public class JavaTemplatesTagValues extends TagValueDefinitionProvider { /** + * Tag value to authorize user to override abstract classes. + * + * By default, user should never override abstract classes but works on implementation ones. + * + * You can globaly use it on the complete model, on packages, or to a specific classifier. + * + * @see #isOverrideAbstractClasses(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + defaultValue = "false", + documentation = "To generate property change support code.") + public static final String TAG_OVERRIDE_ABSTRACT_CLASSES = "overrideAbstractClasses"; + + /** * Tag value to generate property change support on generated beans. * * You can globaly use it on the complete model, on packages, or to a specific classifier. @@ -543,7 +559,26 @@ public class JavaTemplatesTagValues extends TagValueDefinitionProvider { defaultValue = "true", documentation = "To generate or not guava predicates on propertyes on beans.\n" + "(only effective with simple bean with no interface generator)") - public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_FUNCTIONS= "simpleBeanWithNoInterfaceGenerateFunctions"; + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_FUNCTIONS = "simpleBeanWithNoInterfaceGenerateFunctions"; + + /** + * Obtain the value of the {@link #TAG_OVERRIDE_ABSTRACT_CLASSES} tag value on the given model, package or classifier. + * + * It will first look on the model, then and package and then in the given classifier. + * + * If no value found, then will use the default value of the tag value. + * + * @param classifier classifier to seek + * @param aPackage package to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see #TAG_OVERRIDE_ABSTRACT_CLASSES + * @since 3.0 + */ + public boolean isOverrideAbstractClasses(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + boolean value = findBooleanTagValue(TAG_OVERRIDE_ABSTRACT_CLASSES, classifier, aPackage, model); + return value; + } /** * Obtain the value of the {@link #TAG_GENERATE_PROPERTY_CHANGE_SUPPORT} tag value on the given model, package or classifier. @@ -927,7 +962,8 @@ public class JavaTemplatesTagValues extends TagValueDefinitionProvider { boolean value = findBooleanTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_PREDICATES, classifier, aPackage, model); return value; } -/** + + /** * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_FUNCTIONS} tag value on the given model or classifier. * * It will first look on the model, and then in the given classifier. diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java index 886ebce..076df7f 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java @@ -87,10 +87,12 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { String abstractClassName = getAbstractBeanClassName(aPackage, input); String className = getBeanClassName(aPackage, input); String defaultClassName = getBeanDefaultsClassName(aPackage, input); + String abstractDefaultClassName = getBeanAbstractDefaultsClassName(aPackage, input); boolean generateDefaults = canGenerateBeanDefaults(aPackage, input); + boolean generateAbstractDefaults = canGenerateBeanAbstractDefaults(aPackage, input, abstractDefaultClassName); boolean generateInterface = canGenerateInterface(aPackage, input, interfaceName); - boolean generateAbstractClass = canGenerateAbstractBean(input, abstractClassName); + boolean generateAbstractClass = canGenerateAbstractClass(aPackage, input, abstractClassName); boolean generateClass = canGenerateBean(input, className); String prefix = getConstantPrefix(input); @@ -138,7 +140,12 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { if (generateDefaults) { - generateBeanDefaults(aPackage, input, defaultClassName); + generateBeanDefaults(input, abstractDefaultClassName, defaultClassName); + } + + if (generateAbstractDefaults) { + + generateBeanAbstractDefaults(aPackage, input, abstractDefaultClassName); } } @@ -150,8 +157,7 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { String defaultPackage = getDefaultPackageName(); String fqn = defaultPackage + "." + className; - boolean canGenerate = generateFactory && - !isInClassPath(fqn); + boolean canGenerate = generateFactory && !isInClassPath(fqn); return canGenerate; } @@ -170,11 +176,11 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { return canGenerate; } - protected boolean canGenerateAbstractBean(ObjectModelClass input, String className) { - String fqn = input.getPackageName() + "." + className; - boolean canGenerate = !isInClassPath(fqn); - return canGenerate; - } +// protected boolean canGenerateAbstractBean(ObjectModelClass input, String className) { +// String fqn = input.getPackageName() + "." + className; +// boolean canGenerate = !isInClassPath(fqn); +// return canGenerate; +// } protected boolean canGenerateBean(ObjectModelClass input, String className) { String fqn = input.getPackageName() + "." + className; @@ -220,14 +226,10 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { return canGenerate; } - protected boolean canGenerateBeanAbstractDefaults(ObjectModelClass input, - String className) { - - String classPackage = input.getPackageName(); + protected boolean canGenerateBeanAbstractDefaults(ObjectModelPackage aPackage, ObjectModelClass input, String className) { - String fqn = classPackage + "." + className; - - boolean canGenerate = !isInClassPath(fqn); + boolean canGenerate = getJavaTemplatesTagValues().isSimpleBeanGenerateDefaults(input, aPackage, model) + && canGenerateAbstractClass(aPackage, input, className); return canGenerate; } @@ -447,113 +449,104 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { return output; } - protected void generateBeanDefaults(ObjectModelPackage aPackage, - ObjectModelClass aClass, - String defaultClassName) { + protected void generateBeanAbstractDefaults(ObjectModelPackage aPackage, + ObjectModelClass aClass, + String abstractoutclassName) { - boolean generateDefault = canGenerateBeanDefaults(aPackage, aClass); - - if (!generateDefault) { - return; - } String packageName = aClass.getPackageName(); String typeName = getBeanInterfaceName(aPackage, aClass); String typeBeanName = getBeanClassName(aPackage, aClass); - String abstractoutclassName = "Abstract" + defaultClassName; - - if (!isInClassPath(packageName, defaultClassName)) { + // try to find a super class by tag-value + String superClassName = + getJavaTemplatesTagValues().getSimpleBeanDefaultsSuperClassTagValue( + aClass, aPackage, model); - // generate defaults class - - ObjectModelClass output = createClass(defaultClassName, packageName); - setSuperClass(output, packageName + "." + abstractoutclassName); - if (log.isDebugEnabled()) { - log.debug("will generate " + output.getQualifiedName()); - } + ObjectModelClass output = createAbstractClass(abstractoutclassName, packageName); + if (StringUtils.isNotBlank(superClassName)) { + setSuperClass(output, superClassName); } + if (log.isDebugEnabled()) { + log.debug("will generate " + output.getQualifiedName()); + } - if (!isInClassPath(packageName, abstractoutclassName)) { - - // generate abstract defaults class - - // try to find a super class by tag-value - String superClassName = - getJavaTemplatesTagValues().getSimpleBeanDefaultsSuperClassTagValue( - aClass, aPackage, model); - - ObjectModelClass output = createAbstractClass(abstractoutclassName, packageName); - if (StringUtils.isNotBlank(superClassName)) { - setSuperClass(output, superClassName); - } - - if (log.isDebugEnabled()) { - log.debug("will generate " + output.getQualifiedName()); - } - - ObjectModelOperation operation = addOperation( - output, - "typeOf" + typeName, - "<BeanType extends " + typeName + "> Class<BeanType>", - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - setOperationBody(operation, "" + ObjectModelOperation operation = addOperation( + output, + "typeOf" + typeName, + "<BeanType extends " + typeName + "> Class<BeanType>", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + setOperationBody(operation, "" /*{ return (Class<BeanType>) <%=typeBeanName%>.class; }*/ - ); - operation = addOperation( - output, - "new" + typeName, - typeName, - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - setOperationBody(operation, "" + ); + operation = addOperation( + output, + "new" + typeName, + typeName, + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + setOperationBody(operation, "" /*{ return new <%=typeBeanName%>(); }*/ - ); - - addImport(output, Binder.class); - addImport(output, BinderFactory.class); - operation = addOperation( - output, - "new" + typeName, - "<BeanType extends " + typeName + "> BeanType", - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - addParameter(operation, "BeanType", "source"); - setOperationBody(operation, "" + ); + + addImport(output, Binder.class); + addImport(output, BinderFactory.class); + operation = addOperation( + output, + "new" + typeName, + "<BeanType extends " + typeName + "> BeanType", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "BeanType", "source"); + setOperationBody(operation, "" /*{ Class<BeanType> sourceType = typeOf<%=typeName%>(); Binder<BeanType,BeanType> binder = BinderFactory.newBinder(sourceType); BeanType result = new<%=typeName%>(source, binder); return result; }*/ - ); - - operation = addOperation( - output, - "new" + typeName, - "<BeanType extends " + typeName + "> BeanType", - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - addParameter(operation, "BeanType", "source"); - addParameter(operation, "Binder<BeanType, BeanType>", "binder"); - setOperationBody(operation, "" + ); + + operation = addOperation( + output, + "new" + typeName, + "<BeanType extends " + typeName + "> BeanType", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "BeanType", "source"); + addParameter(operation, "Binder<BeanType, BeanType>", "binder"); + setOperationBody(operation, "" /*{ BeanType result = (BeanType) new<%=typeName%>(); binder.copy(source, result); return result; }*/ - ); + ); + + } + + protected void generateBeanDefaults(ObjectModelClass aClass, + String abstractoutclassName, + String defaultClassName) { + + String packageName = aClass.getPackageName(); + + ObjectModelClass output = createClass(defaultClassName, packageName); + setSuperClass(output, packageName + "." + abstractoutclassName); + if (log.isDebugEnabled()) { + log.debug("will generate " + output.getQualifiedName()); } + } protected Collection<ObjectModelOperation> getPublicOperations(ObjectModelClass clazz) { @@ -614,4 +607,14 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { ); } + protected String getBeanAbstractDefaultsClassName(ObjectModelPackage aPackage, ObjectModelClass input) { + String classNamePrefix = getJavaTemplatesTagValues().getSimpleBeanDefaultsClassNamePrefixTagValue(input, aPackage, model); + String classNameSuffix = getJavaTemplatesTagValues().getSimpleBeanDefaultsClassNameSuffixTagValue(input, aPackage, model); + return generateName( + classNamePrefix, + "Abstract" + input.getName(), + classNameSuffix + ); + } + } diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java index f05655f..d14b26a 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java @@ -144,7 +144,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr generateBeanClass(input, className, abstractClassName); } - boolean generateAbstractClass = notFoundInClassPath(input, abstractClassName); + boolean generateAbstractClass = canGenerateAbstractClass(aPackage, input, abstractClassName); if (generateAbstractClass) { generateAbstractBeanClass(aPackage, input, abstractClassName); } -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.