branch develop updated (81fb309 -> ddf7df5)
This is an automated email from the git hooks/post-receive script. New change to branch develop in repository eugene. See http://git.nuiton.org/eugene.git from 81fb309 Improve some generation code new f4438f4 By default, we should always generate abstract classes. new ddf7df5 By default forbids to generate abstract classes (closes #3747) Merge branch 'feature/3747' into develop The 2 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Detailed log of new commits: commit ddf7df5a263c93b139eba2f7db823dffb2545a9a Merge: 81fb309 f4438f4 Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Aug 15 10:13:06 2015 +0200 By default forbids to generate abstract classes (closes #3747) Merge branch 'feature/3747' into develop 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 Summary of changes: .../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(-) -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.
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>.
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 ddf7df5a263c93b139eba2f7db823dffb2545a9a Merge: 81fb309 f4438f4 Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Aug 15 10:13:06 2015 +0200 By default forbids to generate abstract classes (closes #3747) Merge branch 'feature/3747' into develop .../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(-) -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.
participants (1)
-
nuiton.org scm