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 132fc73797577e3926439ae76f000d71a854b286 Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Aug 15 11:11:35 2015 +0200 By default, forbids to write methods in concrete design model Add a tag value acceptBeanWithMethods to remove this check and permits to generate such classes (the design methods are lost here). See #3748 --- .../eugene/java/AbstractJavaBeanTransformer.java | 42 +++++++++- .../nuiton/eugene/java/JavaBeanTransformer.java | 16 +--- .../nuiton/eugene/java/JavaTemplatesTagValues.java | 37 ++++++++- .../eugene/java/SimpleJavaBeanTransformer.java | 94 +++++----------------- .../SimpleJavaBeanWithNoInterfaceTransformer.java | 4 +- 5 files changed, 99 insertions(+), 94 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 cb268dc..c5ffe48 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 @@ -843,10 +843,17 @@ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformer if (!notInClassPath) { boolean canOverride = getJavaTemplatesTagValues().isOverrideAbstractClasses(aclass, aPackage, model); - String fqn = aclass.getPackageName() + "." + abstractClassName; + String packageName = aclass.getPackageName(); + String fqn = packageName + "." + 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."; + String message = "\n=========================================================================================="; + message += "\nCan not override abstract class " + fqn + ", already found in classpath"; + message += "\n\nTo remove this check, add a tag value *overrideAbstractClasses* on model, package or class."; + message += "\n\nmodel.tagvalue.overrideAbstractClasses=true"; + message += "\npackage." + packageName + ".tagvalue.overrideAbstractClasses=true"; + message += "\n" + packageName + "." + aclass.getName() + ".class.tagvalue.overrideAbstractClasses=true"; + message += "\n=========================================================================================="; + throw new IllegalStateException(message); } if (log.isWarnEnabled()) { @@ -858,4 +865,33 @@ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformer } + protected boolean canGenerateClassWithMethods(ObjectModelPackage aPackage, ObjectModelClass aclass, String className) { + + boolean noMethods = aclass.getOperations().isEmpty(); + + if (!noMethods) { + + boolean canOverride = getJavaTemplatesTagValues().isAcceptBeanWithMethods(aclass, aPackage, model); + String packageName = aclass.getPackageName(); + String fqn = packageName + "." + className; + if (!canOverride) { + String message = "\n=========================================================================================="; + message += "\nConcrete class " + fqn + " contains some methods, the current generator does not accept it."; + message += "\n\nSuch methods are not made to be designed, you should directly write them in the concrete class."; + message += "\n\nTo remove this check, add a tag value *acceptBeanWithMethods* on model, package or class:"; + message += "\n\nmodel.tagvalue.acceptBeanWithMethods=true"; + message += "\npackage." + packageName + ".tagvalue.acceptBeanWithMethods=true"; + message += "\n" + packageName + "." + aclass.getName() + ".class.tagvalue.acceptBeanWithMethods=true"; + message += "\n=========================================================================================="; + throw new IllegalStateException(message); + } + if (log.isWarnEnabled()) { + log.warn("Will generate class (but designed methods won't be generated): " + fqn); + } + } + + return true; + + } + } 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 32f4b42..e65e7de 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 @@ -75,13 +75,7 @@ public class JavaBeanTransformer extends AbstractJavaBeanTransformer { } } -// protected boolean canGenerateAbstract(ObjectModelClass input) { -// boolean b = !isInClassPath(input); -// return b; -// } - - protected boolean canGenerateImpl(ObjectModelClass input, - ObjectModelClass abstractOutput) { + protected boolean canGenerateImpl(ObjectModelClass input, ObjectModelClass abstractOutput) { String fqn = input.getQualifiedName() + "Impl"; if (isInClassPath(fqn)) { @@ -103,7 +97,7 @@ public class JavaBeanTransformer extends AbstractJavaBeanTransformer { if (!allOtherOperations.isEmpty()) { Collection<ObjectModelOperation> allExistingOperations = - new ArrayList<ObjectModelOperation>(input.getAllSuperclassOperations(true)); + new ArrayList<>(input.getAllSuperclassOperations(true)); if (abstractOutput != null) { allExistingOperations.addAll(abstractOutput.getOperations()); @@ -121,8 +115,7 @@ public class JavaBeanTransformer extends AbstractJavaBeanTransformer { } - protected void createAbstractOperations(ObjectModelClass ouput, - Iterable<ObjectModelOperation> operations) { + protected void createAbstractOperations(ObjectModelClass ouput, Iterable<ObjectModelOperation> operations) { JavaGeneratorUtil.cloneOperations( this, operations, @@ -227,8 +220,7 @@ public class JavaBeanTransformer extends AbstractJavaBeanTransformer { return resultClassImpl; } - protected void addSuperClass(ObjectModelClass input, - ObjectModelClass output) { + protected void addSuperClass(ObjectModelClass input, ObjectModelClass output) { // Set superclass Iterator<ObjectModelClass> j = input.getSuperclasses().iterator(); if (j.hasNext()) { 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 e2d431a..04f62f7 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 generate some bean with methods, some generators won't generate them : Lots code). + * + * By default, user should never add methods in bean classes, simply write them in your java code!. + * + * You can globaly use it on the complete model, on packages, or to a specific classifier. + * + * @see #isAcceptBeanWithMethods(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + defaultValue = "false", + documentation = "To authorize to generate bean with method (in some generator such method won't be generated).") + public static final String TAG_ACCEPT_BEAN_WITH_METHODS = "acceptBeanWithMethods"; + + /** * Tag value to authorize user to override abstract classes. * * By default, user should never override abstract classes but works on implementation ones. @@ -51,7 +67,7 @@ public class JavaTemplatesTagValues extends TagValueDefinitionProvider { @TagValueDefinition( target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, defaultValue = "false", - documentation = "To generate property change support code.") + documentation = "To authorize to override abstract classes.") public static final String TAG_OVERRIDE_ABSTRACT_CLASSES = "overrideAbstractClasses"; /** @@ -562,6 +578,25 @@ public class JavaTemplatesTagValues extends TagValueDefinitionProvider { public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_FUNCTIONS = "simpleBeanWithNoInterfaceGenerateFunctions"; /** + * Obtain the value of the {@link #TAG_ACCEPT_BEAN_WITH_METHODS} 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_ACCEPT_BEAN_WITH_METHODS + * @since 3.0 + */ + public boolean isAcceptBeanWithMethods(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + boolean value = findBooleanTagValue(TAG_ACCEPT_BEAN_WITH_METHODS, classifier, aPackage, model); + return value; + } + + /** * 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. 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 076df7f..7a4f1a6 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 @@ -83,23 +83,15 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { return; } + String prefix = getConstantPrefix(input); + setConstantPrefix(prefix); + String interfaceName = getBeanInterfaceName(aPackage, input); - String abstractClassName = getAbstractBeanClassName(aPackage, input); String className = getBeanClassName(aPackage, input); - String defaultClassName = getBeanDefaultsClassName(aPackage, input); - String abstractDefaultClassName = getBeanAbstractDefaultsClassName(aPackage, input); + String abstractClassName = "Abstract" + className; - boolean generateDefaults = canGenerateBeanDefaults(aPackage, input); - boolean generateAbstractDefaults = canGenerateBeanAbstractDefaults(aPackage, input, abstractDefaultClassName); - boolean generateInterface = canGenerateInterface(aPackage, input, interfaceName); boolean generateAbstractClass = canGenerateAbstractClass(aPackage, input, abstractClassName); - boolean generateClass = canGenerateBean(input, className); - - String prefix = getConstantPrefix(input); - setConstantPrefix(prefix); - ObjectModelClass outputAbstractClass = null; - if (generateAbstractClass) { outputAbstractClass = generateAbstractBeanClass(aPackage, @@ -108,6 +100,7 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { interfaceName); } + boolean generateInterface = canGenerateInterface(aPackage, input, interfaceName); if (generateInterface) { ObjectModelClass outputAbstractClass1 = outputAbstractClass; @@ -132,17 +125,25 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { } + boolean generateClass = notFoundInClassPath(input, className) + && canGenerateClassWithMethods(aPackage, input, className); + if (generateClass) { generateBeanClass(input, className, abstractClassName); } + String defaultClassName = getBeanDefaultsClassName(aPackage, input); + String abstractDefaultClassName = "Abstract" + defaultClassName; + boolean generateDefaults = canGenerateBeanDefaults(aPackage, input, defaultClassName); if (generateDefaults) { generateBeanDefaults(input, abstractDefaultClassName, defaultClassName); } + boolean generateAbstractDefaults = getJavaTemplatesTagValues().isSimpleBeanGenerateDefaults(input, aPackage, model) + && canGenerateAbstractClass(aPackage, input, abstractDefaultClassName); if (generateAbstractDefaults) { generateBeanAbstractDefaults(aPackage, input, abstractDefaultClassName); @@ -169,46 +170,17 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { boolean generateInterface = getJavaTemplatesTagValues().isSimpleBeanGenerateInterface(input, aPackage, model); - String fqn = input.getPackageName() + "." + className; - - boolean canGenerate = generateInterface && !isInClassPath(fqn); - + boolean canGenerate = generateInterface && notFoundInClassPath(input, className); 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; - boolean canGenerate = !isInClassPath(fqn); - if (canGenerate) { - - // check there is no operation on input - if (!input.getOperations().isEmpty()) { - - canGenerate = false; -// throw new GeneratorException( -// "Can't generate a simple bean as class " + -// fqn + -// " contains so operations." + -// "\nUse instead the JavaBeanTransformer."); - } - } - return canGenerate; } - protected boolean canGenerateBeanDefaults(ObjectModelPackage aPackage, ObjectModelClass input) { + protected boolean canGenerateBeanDefaults(ObjectModelPackage aPackage, ObjectModelClass input, String className) { boolean withInput = input != null; - boolean canGenerate = - getJavaTemplatesTagValues().isSimpleBeanGenerateDefaults( - input, aPackage, model); + boolean canGenerate = notFoundInClassPath(input, className) + && getJavaTemplatesTagValues().isSimpleBeanGenerateDefaults(input, aPackage, model); if (canGenerate) { @@ -217,8 +189,7 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { // class in not abstract // class is a bean - canGenerate = !input.isAbstract() && - JavaTemplatesStereoTypes.hasBeanStereotype(input, aPackage); + canGenerate = !input.isAbstract() && JavaTemplatesStereoTypes.hasBeanStereotype(input, aPackage); } } @@ -226,14 +197,6 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { return canGenerate; } - protected boolean canGenerateBeanAbstractDefaults(ObjectModelPackage aPackage, ObjectModelClass input, String className) { - - boolean canGenerate = getJavaTemplatesTagValues().isSimpleBeanGenerateDefaults(input, aPackage, model) - && canGenerateAbstractClass(aPackage, input, className); - - return canGenerate; - } - protected void generateBeanFactory(ObjectModel model, String className) { String defaultPackage = getDefaultPackageName(); @@ -586,17 +549,6 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { ); } - protected String getAbstractBeanClassName(ObjectModelPackage aPackage, ObjectModelClass input) { - String classNamePrefix = getJavaTemplatesTagValues().getSimpleBeanClassNamePrefixTagValue(input, aPackage, model); - String classNameSuffix = getJavaTemplatesTagValues().getSimpleBeanClassNameSuffixTagValue(input, aPackage, model); - - return generateName( - classNamePrefix, - "Abstract" + input.getName(), - classNameSuffix - ); - } - protected String getBeanDefaultsClassName(ObjectModelPackage aPackage, ObjectModelClass input) { String classNamePrefix = getJavaTemplatesTagValues().getSimpleBeanDefaultsClassNamePrefixTagValue(input, aPackage, model); String classNameSuffix = getJavaTemplatesTagValues().getSimpleBeanDefaultsClassNameSuffixTagValue(input, aPackage, model); @@ -607,14 +559,4 @@ 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 d14b26a..cf83f8d 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 @@ -138,8 +138,8 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr String className = beanNameTranslation.get(input); String abstractClassName = "Abstract" + className; - - boolean generateClass = input.getOperations().isEmpty() && notFoundInClassPath(input, className); + boolean generateClass = notFoundInClassPath(input, className) + && canGenerateClassWithMethods(aPackage, input, className); if (generateClass) { generateBeanClass(input, className, abstractClassName); } -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.