Author: tchemit Date: 2013-09-29 16:23:58 +0200 (Sun, 29 Sep 2013) New Revision: 1301 Url: http://nuiton.org/projects/eugene/repository/revisions/1301 Log: add superclass for defaults class refs #2861: [SimpleBean] Generate default class helper for each Bean Modified: trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesGeneratorUtil.java trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java Modified: trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesGeneratorUtil.java =================================================================== --- trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesGeneratorUtil.java 2013-09-29 09:38:41 UTC (rev 1300) +++ trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesGeneratorUtil.java 2013-09-29 14:23:58 UTC (rev 1301) @@ -24,6 +24,7 @@ * #L% */ +import org.apache.commons.lang3.StringUtils; import org.nuiton.eugene.models.object.ObjectModel; import org.nuiton.eugene.models.object.ObjectModelClassifier; @@ -110,9 +111,9 @@ * @see JavaTemplatesTagValues#TAG_SIMPLE_BEAN_GENERATE_INTERFACE * @since 2.3 */ - public static String getSimpleBeanGenerateInterfaceTagValue(ObjectModel model, ObjectModelClassifier classifier) { + public static boolean isSimpleBeanGenerateInterface(ObjectModel model, ObjectModelClassifier classifier) { String value = findTagValue(JavaTemplatesTagValues.TAG_SIMPLE_BEAN_GENERATE_INTERFACE, classifier, model); - return value; + return value != null && "true".equals(value); } /** @@ -224,10 +225,66 @@ * @param classifier classifier to seek * @return the none empty value of the found tag value or {@code null} if not found nor empty. * @see JavaTemplatesTagValues#TAG_SIMPLE_BEAN_GENERATE_DEFAULTS - * @since 2.6.2 + * @since 2.7.2 */ public static boolean isSimpleBeanGenerateDefaults(ObjectModel model, ObjectModelClassifier classifier) { String value = findTagValue(JavaTemplatesTagValues.TAG_SIMPLE_BEAN_GENERATE_DEFAULTS, classifier, model); return value != null && "true".equals(value); } + + /** + * Obtain the value of the {@link JavaTemplatesTagValues#TAG_SIMPLE_BEAN_DEFAULTS_SUPER_CLASS} + * tag value on the given model or classifier. + * <p/> + * It will first look on the model, and then in the given classifier. + * + * @param model model to seek + * @param classifier classifier to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see JavaTemplatesTagValues#TAG_SIMPLE_BEAN_DEFAULTS_SUPER_CLASS + * @since 2.7.2 + */ + public static String getSimpleBeanDefaultsSuperClassTagValue(ObjectModel model, ObjectModelClassifier classifier) { + String value = findTagValue(JavaTemplatesTagValues.TAG_SIMPLE_BEAN_DEFAULTS_SUPER_CLASS, classifier, model); + return value; + } + + /** + * Obtain the value of the {@link JavaTemplatesTagValues#TAG_SIMPLE_BEAN_DEFAULTS_CLASS_NAME_PREFIX} + * tag value on the given model or classifier. + * <p/> + * It will first look on the model, and then in the given classifier. + * + * @param model model to seek + * @param classifier classifier to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see JavaTemplatesTagValues#TAG_SIMPLE_BEAN_DEFAULTS_CLASS_NAME_PREFIX + * @since 2.7.2 + */ + public static String getSimpleBeanDefaultsClassNamePrefixTagValue(ObjectModel model, ObjectModelClassifier classifier) { + String value = findTagValue(JavaTemplatesTagValues.TAG_SIMPLE_BEAN_DEFAULTS_CLASS_NAME_PREFIX, classifier, model); + return value; + } + + /** + * Obtain the value of the {@link JavaTemplatesTagValues#TAG_SIMPLE_BEAN_DEFAULTS_CLASS_NAME_SUFFIX} + * tag value on the given model or classifier. + * <p/> + * It will first look on the model, and then in the given classifier. + * + * <strong>If not filled, then use default {@code s} value.</strong> + * + * @param model model to seek + * @param classifier classifier to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see JavaTemplatesTagValues#TAG_SIMPLE_BEAN_DEFAULTS_CLASS_NAME_SUFFIX + * @since 2.6.2 + */ + public static String getSimpleBeanDefaultsClassNameSuffixTagValue(ObjectModel model, ObjectModelClassifier classifier) { + String value = findTagValue(JavaTemplatesTagValues.TAG_SIMPLE_BEAN_DEFAULTS_CLASS_NAME_SUFFIX, classifier, model); + if (StringUtils.isBlank(value)) { + value = "s"; + } + return value; + } } Modified: trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java =================================================================== --- trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java 2013-09-29 09:38:41 UTC (rev 1300) +++ trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java 2013-09-29 14:23:58 UTC (rev 1301) @@ -214,7 +214,7 @@ * <p/> * You can globaly use it on the complete model or to a specific classifier. * - * @see JavaTemplatesGeneratorUtil#getSimpleBeanGenerateInterfaceTagValue(ObjectModel, ObjectModelClassifier) + * @see JavaTemplatesGeneratorUtil#isSimpleBeanGenerateInterface(ObjectModel, ObjectModelClassifier) * @since 2.6.2 */ @ModelPropertiesUtil.TagValueDefinition( @@ -296,4 +296,52 @@ documentation = "To generate defaults class with simple operations on the type.\n" + "(only effective with simple bean generator)") String TAG_SIMPLE_BEAN_GENERATE_DEFAULTS = "simpleBeanGenerateDefaults"; + + /** + * Tag value to use a super super-class for generated defaults class of a + * simple bean. + * <p/> + * You can globaly use it on the complete model or to a specific classifier. + * + * @see JavaTemplatesGeneratorUtil#getSimpleBeanDefaultsSuperClassTagValue(ObjectModel, ObjectModelClassifier) + * @since 2.7.2 + */ + @ModelPropertiesUtil.TagValueDefinition( + target = {ObjectModel.class, ObjectModelClassifier.class}, + documentation = "To specify a super-class to used on generated defaults classes" + + "for a bean or any bean of a model.\n" + + "(only effective with simple bean generator)") + String TAG_SIMPLE_BEAN_DEFAULTS_SUPER_CLASS = "simpleBeanDefaultsSuperClass"; + + /** + * To add a prefix on the name of each generated bean class. + * <p/> + * You can globaly use it on the complete model or to a specific classifier. + * + * @see JavaTemplatesGeneratorUtil#getSimpleBeanDefaultsClassNamePrefixTagValue(ObjectModel, ObjectModelClassifier) + * @since 2.7.2 + */ + @ModelPropertiesUtil.TagValueDefinition( + target = {ObjectModel.class, ObjectModelClassifier.class}, + documentation = "To add a prefix on class name of generated defaults bean " + + "for a class or any class of a model.\n" + + "(only effective with simple bean generator)") + String TAG_SIMPLE_BEAN_DEFAULTS_CLASS_NAME_PREFIX = "simpleBeanDefaultsClassNamePrefix"; + + /** + * To add a suffix on the name of each generated bean class. + * <p/> + * You can globaly use it on the complete model or to a specific classifier. + * + * @see JavaTemplatesGeneratorUtil#getSimpleBeanDefaultsClassNameSuffixTagValue(ObjectModel, ObjectModelClassifier) + * @since 2.6.2 + */ + @ModelPropertiesUtil.TagValueDefinition( + target = {ObjectModel.class, ObjectModelClassifier.class}, + documentation = "To add a suffix on class name of generated defaults bean " + + "for a class or any class of a model.\n" + + "(only effective with simple bean generator)") + String TAG_SIMPLE_BEAN_DEFAULTS_CLASS_NAME_SUFFIX = "simpleBeanDefaultsClassNameSuffix"; + + } Modified: trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java =================================================================== --- trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java 2013-09-29 09:38:41 UTC (rev 1300) +++ trunk/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java 2013-09-29 14:23:58 UTC (rev 1301) @@ -72,10 +72,6 @@ generateBeanFactory(model, className); } - - if (canGenerateBeanDefaults(model, null)) { - generateBeanDefaults(model); - } } @Override @@ -89,7 +85,10 @@ String interfaceName = getBeanInterfaceName(input); String className = getBeanClassName(input); + String defaultClassName = getBeanDefaultsClassName(input); + boolean generateDefaults = canGenerateBeanDefaults(input); + boolean generateInterface = canGenerateInterface(input, interfaceName); boolean generateClass = canGenerateBean(input, className); @@ -123,7 +122,10 @@ } } + if (generateDefaults) { + generateBeanDefaults(input, defaultClassName); + } } protected boolean canGenerateFactory(ObjectModel model, String className) { @@ -144,12 +146,12 @@ protected boolean canGenerateInterface(ObjectModelClass input, String className) { - String generateTagValue = - JavaTemplatesGeneratorUtil.getSimpleBeanGenerateInterfaceTagValue(model, input); + boolean generateInterface = + JavaTemplatesGeneratorUtil.isSimpleBeanGenerateInterface(model, input); - boolean generateInterface = generateTagValue != null && - Boolean.valueOf(generateTagValue); - +// boolean generateInterface = generateTagValue != null && +// Boolean.valueOf(generateTagValue); +// String fqn = input.getPackageName() + "." + className; boolean canGenerate = generateInterface && !isInClassPath(fqn); @@ -188,8 +190,7 @@ return canGenerate; } - protected boolean canGenerateBeanDefaults(ObjectModel model, - ObjectModelClass input) { + protected boolean canGenerateBeanDefaults(ObjectModelClass input) { boolean withInput = input != null; @@ -390,7 +391,7 @@ // Get available properties List<ObjectModelAttribute> properties = getProperties(input); - boolean usePCS= !JavaTemplatesGeneratorUtil.isNoPCS(model, input); + boolean usePCS = !JavaTemplatesGeneratorUtil.isNoPCS(model, input); // boolean usePCS = StringUtils.isEmpty(noPCSTagValue) || // !"true".equals(noPCSTagValue.trim()); @@ -416,86 +417,87 @@ return output; } - protected void generateBeanDefaults(ObjectModel model) { + protected void generateBeanDefaults(ObjectModelClass aClass, + String defaultClassName) { - for (ObjectModelClass aClass : model.getClasses()) { + boolean generateDefault = canGenerateBeanDefaults(aClass); - boolean generateDefault = canGenerateBeanDefaults(model, aClass); + if (!generateDefault) { + return; + } - if (!generateDefault) { - continue; - } + String packageName = aClass.getPackageName(); + String typeName = getBeanInterfaceName(aClass); + String typeBeanName = getBeanClassName(aClass); - String packageName = aClass.getPackageName(); - String typeName = getBeanInterfaceName(aClass); - String typeBeanName = getBeanClassName(aClass); + String abstractoutclassName = "Abstract" + defaultClassName; - String outclassName = typeName + "s"; - String abstractoutclassName = "Abstract" + outclassName; + if (!isInClassPath(packageName, defaultClassName)) { - if (!isInClassPath(packageName, outclassName)) { + // generate defaults class - // generate defaults class - - ObjectModelClass output = createClass(outclassName, packageName); -// addImport(output, packageName + "." + typeName); -// addImport(output, packageName + "." + typeBeanName); - setSuperClass(output, packageName + "." + abstractoutclassName); - if (log.isDebugEnabled()) { - log.debug("will generate " + output.getQualifiedName()); - } + ObjectModelClass output = createClass(defaultClassName, packageName); + setSuperClass(output, packageName + "." + abstractoutclassName); + if (log.isDebugEnabled()) { + log.debug("will generate " + output.getQualifiedName()); } + } - if (!isInClassPath(packageName, abstractoutclassName)) { + if (!isInClassPath(packageName, abstractoutclassName)) { - // generate abstract defaults class + // generate abstract defaults class - ObjectModelClass output = createAbstractClass(abstractoutclassName, packageName); + // try to find a super class by tag-value + String superClassName = + JavaTemplatesGeneratorUtil.getSimpleBeanDefaultsSuperClassTagValue( + model, aClass); -// addImport(output, packageName + "." + typeName); -// addImport(output, packageName + "." + typeBeanName); + ObjectModelClass output = createAbstractClass(abstractoutclassName, packageName); + setSuperClass(output, superClassName); +// if (superClassName != null) { +// } - if (log.isDebugEnabled()) { - log.debug("will generate " + output.getQualifiedName()); - } + 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, "" /*{ BeanType result = (BeanType) new<%=typeName%>(); Class<BeanType> sourceType = typeOf<%=typeName%>(); @@ -503,8 +505,7 @@ binder.copy(source, result); return result; }*/ - ); - } + ); } } @@ -545,6 +546,16 @@ ); } + protected String getBeanDefaultsClassName(ObjectModelClass input) { + String classNamePrefix = JavaTemplatesGeneratorUtil.getSimpleBeanDefaultsClassNamePrefixTagValue(model, input); + String classNameSuffix = JavaTemplatesGeneratorUtil.getSimpleBeanDefaultsClassNameSuffixTagValue(model, input); + return generateName( + classNamePrefix, + input.getName(), + classNameSuffix + ); + } + protected String generateName(String prefix, String name, String suffix) {