[Eugene-commits] 01/01: Improve some generation code

14 Aug 2015

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 81fb30993a1e6da58d9815ae3dd7a1c0ed6cb06d
Author: Tony CHEMIT <chemit@codelutin.com>
Date:   Fri Aug 14 22:25:31 2015 +0200

    Improve some generation code
---
 .../eugene/java/AbstractJavaBeanTransformer.java   |  36 ++
 .../eugene/java/SimpleJavaBeanTransformer.java     |  13 -
 .../SimpleJavaBeanWithNoInterfaceTransformer.java  | 504 ++++++++++-----------
 .../main/java/org/nuiton/eugene/GeneratorUtil.java |   2 +-
 4 files changed, 268 insertions(+), 287 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 6c6c053..4f35699 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
@@ -64,6 +64,12 @@ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformer
         return javaTemplatesTagValues;
     }
 
+    protected boolean notFoundInClassPath(ObjectModelClass input, String className) {
+        String fqn = input.getPackageName() + "." + className;
+        boolean inClassPath = isInClassPath(fqn);
+        return !inClassPath;
+    }
+
     protected void createPropertyConstant(ObjectModelClassifier output,
                                           ObjectModelAttribute attr,
                                           String prefix,
@@ -795,4 +801,34 @@ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformer
             createGetChildMethod(output);
         }
     }
+
+    protected String wrapPrimitiveType(String attrType) {
+        if (JavaGeneratorUtil.isPrimitiveType(attrType)) {
+            attrType = JavaGeneratorUtil.getPrimitiveWrapType(attrType);
+        }
+        return attrType;
+    }
+
+    protected String getGetterName(ObjectModelAttribute attribute, String attrName) {
+        boolean booleanProperty = JavaGeneratorUtil.isBooleanPrimitive(attribute);
+        String methodPrefix = JavaGeneratorUtil.OPERATION_GETTER_DEFAULT_PREFIX;
+        if (booleanProperty) {
+            methodPrefix = JavaGeneratorUtil.OPERATION_GETTER_BOOLEAN_PREFIX;
+        }
+        String getterName = getJavaBeanMethodName(methodPrefix, attrName);
+        return getterName;
+    }
+
+    protected String generateName(String prefix, String name, String suffix) {
+        StringBuilder sb = new StringBuilder();
+        if (StringUtils.isNotEmpty(prefix)) {
+            sb.append(prefix);
+        }
+        sb.append(name);
+        if (StringUtils.isNotEmpty(suffix)) {
+            sb.append(suffix);
+        }
+        return sb.toString();
+    }
+
 }
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 bca0931..886ebce 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
@@ -614,17 +614,4 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer {
         );
     }
 
-    protected String generateName(String prefix,
-                                  String name,
-                                  String suffix) {
-        StringBuilder sb = new StringBuilder();
-        if (StringUtils.isNotEmpty(prefix)) {
-            sb.append(prefix);
-        }
-        sb.append(name);
-        if (StringUtils.isNotEmpty(suffix)) {
-            sb.append(suffix);
-        }
-        return sb.toString();
-    }
 }
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 e051166..f05655f 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
@@ -28,12 +28,14 @@ package org.nuiton.eugene.java;
 import com.google.common.base.Function;
 import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Maps;
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.nuiton.eugene.models.object.ObjectModel;
 import org.nuiton.eugene.models.object.ObjectModelAttribute;
 import org.nuiton.eugene.models.object.ObjectModelClass;
 import org.nuiton.eugene.models.object.ObjectModelJavaModifier;
@@ -67,83 +69,106 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
     /** Logger. */
     private static final Log log = LogFactory.getLog(SimpleJavaBeanWithNoInterfaceTransformer.class);
 
+    ImmutableMap<ObjectModelClass, String> beanNameTranslation;
+
+    ImmutableMap<ObjectModelClass, String> beanDefaultsNameTranslation;
+
+    ImmutableSet<ObjectModelClass> beanClasses;
+
+    ImmutableSet<ObjectModelClass> beanDefaultClasses;
+
     @Override
-    public void transformFromClass(ObjectModelClass input) {
+    public void transformFromModel(ObjectModel model) {
+        super.transformFromModel(model);
 
-        ObjectModelPackage aPackage = getPackage(input);
+        ImmutableMap.Builder<ObjectModelClass, String> beanNameTranslationBuilder = new ImmutableMap.Builder<>();
+        ImmutableMap.Builder<ObjectModelClass, String> beanDefaultsNameTranslationBuilder = new ImmutableMap.Builder<>();
+        ImmutableSet.Builder<ObjectModelClass> beanClassesBuilder = new ImmutableSet.Builder<>();
+        ImmutableSet.Builder<ObjectModelClass> beanDefaultClassesBuilder = new ImmutableSet.Builder<>();
 
-        if (JavaTemplatesStereoTypes.hasBeanStereotype(input, aPackage)) {
+        JavaTemplatesTagValues javaTemplatesTagValues = getJavaTemplatesTagValues();
 
-            String className = getBeanClassName(aPackage, input);
-            String abstractClassName = "Abstract" + className;
-            String defaultClassName = getBeanDefaultsClassName(aPackage, input);
-            String abstractDefaultClassName = "Abstract" + defaultClassName;
+        for (ObjectModelClass aClass : model.getClasses()) {
 
-            boolean generateDefaults = canGenerateBeanDefaults(aPackage, input);
-            boolean generateAbstractClass = canGenerateAbstractBean(input, abstractClassName);
-            boolean generateClass = canGenerateBean(input, className);
+            ObjectModelPackage aPackage = model.getPackage(aClass.getPackageName());
+            if (JavaTemplatesStereoTypes.hasBeanStereotype(aClass, aPackage)) {
 
-            String prefix = getConstantPrefix(input);
-            setConstantPrefix(prefix);
+                beanClassesBuilder.add(aClass);
 
-            if (generateAbstractClass) {
-                generateAbstractBeanClass(aPackage, input, abstractClassName);
-            }
+                String classNamePrefix = javaTemplatesTagValues.getSimpleBeanWithNoInterfaceClassNamePrefixTagValue(aClass, aPackage, model);
+                String classNameSuffix = javaTemplatesTagValues.getSimpleBeanWithNoInterfaceClassNameSuffixTagValue(aClass, aPackage, model);
 
-            if (generateClass) {
-                generateBeanClass(input, className, abstractClassName);
-            }
+                String generateName = generateName(classNamePrefix, aClass.getName(), classNameSuffix);
+                beanNameTranslationBuilder.put(aClass, generateName);
+
+                boolean canGenerateDefaults = javaTemplatesTagValues.isSimpleBeanWithNoInterfaceGenerateDefaults(aClass, aPackage, model);
+
+                if (canGenerateDefaults) {
+
+                    beanDefaultClassesBuilder.add(aClass);
+
+                    String classDefaultsNamePrefix = javaTemplatesTagValues.getSimpleBeanWithNoInterfaceDefaultsClassNamePrefixTagValue(aClass, aPackage, model);
+                    String classDefaultsNameSuffix = javaTemplatesTagValues.getSimpleBeanWithNoInterfaceDefaultsClassNameSuffixTagValue(aClass, aPackage, model);
+
+                    String generateDefaultsName = generateName(classDefaultsNamePrefix, aClass.getName(), classDefaultsNameSuffix);
+                    beanDefaultsNameTranslationBuilder.put(aClass, generateDefaultsName);
+
+                }
 
-            if (generateDefaults) {
-                generateBeanDefaults(aPackage, input, className, abstractDefaultClassName, defaultClassName);
             }
         }
 
-    }
+        beanClasses = beanClassesBuilder.build();
+        beanDefaultClasses = beanDefaultClassesBuilder.build();
+        beanNameTranslation = beanNameTranslationBuilder.build();
+        beanDefaultsNameTranslation = beanDefaultsNameTranslationBuilder.build();
 
-    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);
+    @Override
+    public void transformFromClass(ObjectModelClass input) {
+
+        ObjectModelPackage aPackage = getPackage(input);
+
+        if (beanClasses.contains(input)) {
 
-        if (canGenerate) {
+            String prefix = getConstantPrefix(input);
+            setConstantPrefix(prefix);
+
+            String className = beanNameTranslation.get(input);
+            String abstractClassName = "Abstract" + className;
 
-            // 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.");
+            boolean generateClass = input.getOperations().isEmpty() && notFoundInClassPath(input, className);
+            if (generateClass) {
+                generateBeanClass(input, className, abstractClassName);
             }
-        }
-        return canGenerate;
-    }
 
-    protected boolean canGenerateBeanDefaults(ObjectModelPackage aPackage, ObjectModelClass input) {
+            boolean generateAbstractClass = notFoundInClassPath(input, abstractClassName);
+            if (generateAbstractClass) {
+                generateAbstractBeanClass(aPackage, input, abstractClassName);
+            }
+
+            boolean generateDefaults = beanDefaultClasses.contains(input);
+            if (generateDefaults) {
 
-        boolean withInput = input != null;
+                String defaultClassName = beanDefaultsNameTranslation.get(input);
+                String abstractDefaultClassName = "Abstract" + defaultClassName;
 
-        boolean canGenerate = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGenerateDefaults(input, aPackage, model);
+                if (notFoundInClassPath(input, defaultClassName)) {
 
-        if (canGenerate) {
+                    generateBeanDefaults(input, abstractDefaultClassName, defaultClassName);
+                }
 
-            if (withInput) {
+                if (notFoundInClassPath(input, defaultClassName)) {
 
-                // class is a bean
-                canGenerate = JavaTemplatesStereoTypes.hasBeanStereotype(input, aPackage);
+                    generateAbstractBeanDefaults(aPackage, input, className, abstractDefaultClassName);
+                }
 
             }
+
         }
 
-        return canGenerate;
     }
 
     protected ObjectModelClass generateBeanClass(ObjectModelClass input,
@@ -180,13 +205,12 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
         Collection<ObjectModelClass> superclasses = input.getSuperclasses();
         if (CollectionUtils.isNotEmpty(superclasses)) {
             for (ObjectModelClass superclass : superclasses) {
-                if (JavaTemplatesStereoTypes.hasBeanStereotype(superclass, aPackage)) {
-                    superClassIsBean = true;
-                    superClass = superclass.getPackageName() + "." + getBeanClassName(aPackage, superclass);
+                superClassIsBean = beanClasses.contains(superclass);
+                if (superClassIsBean) {
+                    superClass = beanNameTranslation.get(superclass);
                     break;
-                } else {
-                    superClass = superclass.getQualifiedName();
                 }
+                superClass = superclass.getQualifiedName();
             }
         }
 
@@ -224,7 +248,6 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
         List<ObjectModelAttribute> properties = getProperties(input);
 
         boolean usePCS = getJavaTemplatesTagValues().isGeneratePropertyChangeSupport(input, aPackage, model);
-
         boolean generateBooleanGetMethods = getEugeneTagValues().isGenerateBooleanGetMethods(input, aPackage, model);
         boolean generateNotEmptyCollections = getJavaTemplatesTagValues().isGenerateNotEmptyCollections(input, aPackage, model);
 
@@ -244,213 +267,160 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
         return output;
     }
 
-    protected void generateBeanDefaults(ObjectModelPackage aPackage,
-                                        ObjectModelClass aClass,
-                                        String typeName,
-                                        String abstractClassName,
-                                        String defaultClassName) {
+    protected void generateBeanDefaults(ObjectModelClass aClass, String abstractClassName, String defaultClassName) {
 
-        boolean generateDefault = canGenerateBeanDefaults(aPackage, aClass);
+        String packageName = aClass.getPackageName();
 
-        if (!generateDefault) {
-            return;
+        ObjectModelClass output = createClass(defaultClassName, packageName);
+        setSuperClass(output, packageName + "." + abstractClassName);
+        if (log.isDebugEnabled()) {
+            log.debug("will generate " + output.getQualifiedName());
         }
 
-        String packageName = aClass.getPackageName();
-//        String typeName = getBeanInterfaceName(aPackage, aClass);
-//        String typeBeanName = getBeanClassName(aPackage, aClass);
+    }
 
-        if (!isInClassPath(packageName, defaultClassName)) {
+    protected void generateAbstractBeanDefaults(ObjectModelPackage aPackage,
+                                                ObjectModelClass aClass,
+                                                String typeName,
+                                                String abstractClassName) {
 
-            // generate defaults class
+        ObjectModelClass output = createAbstractClass(abstractClassName, aPackage.getName());
+        String superClassName = getAbstractDefaultsSuperClassName(aPackage, aClass);
 
-            ObjectModelClass output = createClass(defaultClassName, packageName);
-            setSuperClass(output, packageName + "." + abstractClassName);
-            if (log.isDebugEnabled()) {
-                log.debug("will generate " + output.getQualifiedName());
-            }
+        if (StringUtils.isNotBlank(superClassName)) {
+            setSuperClass(output, superClassName);
         }
 
-        if (!isInClassPath(packageName, abstractClassName)) {
-
-            boolean generatePredicates = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGeneratePredicates(aClass, aPackage, model);
-            boolean generateFunctions = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGenerateFunctions(aClass, aPackage, model);
-            boolean generateContructors = !aClass.isAbstract();
-
-            String superClassName = null;
-
-            // test if a super class has bean stereotype
-            boolean superClassIsBean = false;
-            Collection<ObjectModelClass> superclasses = aClass.getSuperclasses();
-            if (CollectionUtils.isNotEmpty(superclasses)) {
-                for (ObjectModelClass superclass : superclasses) {
-                    if (JavaTemplatesStereoTypes.hasBeanStereotype(superclass, aPackage)) {
-                        superClassIsBean = true;
-                        superClassName = superclass.getPackageName() + "." + getBeanDefaultsClassName(aPackage, superclass);
-                        break;
-                    } else {
-                        superClassName = superclass.getQualifiedName();
-                    }
-                }
-            }
-
-            if (!superClassIsBean) {
-
-                // try to find a super class by tag-value
-                superClassName = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceDefaultsSuperClassTagValue(aClass, aPackage, model);
+        if (log.isDebugEnabled()) {
+            log.debug("will generate " + output.getQualifiedName());
+        }
 
-            }
+        addImport(output, Binder.class);
+        addImport(output, BinderFactory.class);
+
+        ObjectModelOperation operation = addOperation(
+                output,
+                "typeOf" + typeName,
+                "<BeanType extends " + typeName + "> Class<BeanType>",
+                ObjectModelJavaModifier.STATIC,
+                ObjectModelJavaModifier.PUBLIC
+        );
+        setOperationBody(operation, ""
+    /*{
+        return (Class<BeanType>) <%=typeName%>.class;
+    }*/
+        );
 
-            // generate abstract defaults class
+        boolean generateContructors = !aClass.isAbstract();
+        if (generateContructors) {
+            generateAbstractBeanDefaultsConstructors(output, typeName);
+        }
 
-            ObjectModelClass output = createAbstractClass(abstractClassName, packageName);
-            if (StringUtils.isNotBlank(superClassName)) {
-                setSuperClass(output, superClassName);
-            }
+        generateAbstractBeanDefaultsCopyMethods(output, typeName);
 
-            if (log.isDebugEnabled()) {
-                log.debug("will generate " + output.getQualifiedName());
-            }
+        boolean generatePredicates = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGeneratePredicates(aClass, aPackage, model);
+        if (generatePredicates) {
+            generateAbstractBeanDefaultsPredicates(aClass, output, typeName);
+        }
 
-            addImport(output, Binder.class);
-            addImport(output, BinderFactory.class);
+        boolean generateFunctions = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGenerateFunctions(aClass, aPackage, model);
+        if (generateFunctions) {
+            generateAbstractBeanDefaultsFunctions(aClass, output, typeName);
+        }
 
-            ObjectModelOperation operation = addOperation(
-                    output,
-                    "typeOf" + typeName,
-                    "<BeanType extends " + typeName + "> Class<BeanType>",
-                    ObjectModelJavaModifier.STATIC,
-                    ObjectModelJavaModifier.PUBLIC
-            );
-            setOperationBody(operation, ""
-    /*{
-        return (Class<BeanType>) <%=typeName%>.class;
-    }*/
-            );
+    }
 
-            if (generateContructors) {
+    protected void generateAbstractBeanDefaultsConstructors(ObjectModelClass output, String typeName) {
 
-                operation = addOperation(
-                        output,
-                        "new" + typeName,
-                        typeName,
-                        ObjectModelJavaModifier.STATIC,
-                        ObjectModelJavaModifier.PUBLIC
-                );
-                setOperationBody(operation, ""
+        ObjectModelOperation operation = addOperation(
+                output,
+                "new" + typeName,
+                typeName,
+                ObjectModelJavaModifier.STATIC,
+                ObjectModelJavaModifier.PUBLIC
+        );
+        setOperationBody(operation, ""
     /*{
         return new <%=typeName%>();
     }*/
-                );
-
-                operation = addOperation(
-                        output,
-                        "new" + typeName,
-                        "<BeanType extends " + typeName + "> BeanType",
-                        ObjectModelJavaModifier.STATIC,
-                        ObjectModelJavaModifier.PUBLIC
-                );
-                addParameter(operation, "BeanType", "source");
-                setOperationBody(operation, ""
+        );
+
+        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;
     }*/
-                );
-
-            }
+        );
 
+    }
 
-            operation = addOperation(
-                    output,
-                    "copy" + typeName,
-                    "<BeanType extends " + typeName + "> void",
-                    ObjectModelJavaModifier.STATIC,
-                    ObjectModelJavaModifier.PUBLIC
-            );
-            addParameter(operation, "BeanType", "source");
-            addParameter(operation, "BeanType", "target");
-            setOperationBody(operation, ""
+    protected void generateAbstractBeanDefaultsCopyMethods(ObjectModelClass output, String typeName) {
+
+        ObjectModelOperation operation = addOperation(
+                output,
+                "copy" + typeName,
+                "<BeanType extends " + typeName + "> void",
+                ObjectModelJavaModifier.STATIC,
+                ObjectModelJavaModifier.PUBLIC
+        );
+        addParameter(operation, "BeanType", "source");
+        addParameter(operation, "BeanType", "target");
+        setOperationBody(operation, ""
     /*{
         Class<BeanType> sourceType = typeOf<%=typeName%>();
         Binder<BeanType, BeanType> binder = BinderFactory.newBinder(sourceType);
         binder.copy(source, target);
     }*/
-            );
-
-            operation = addOperation(
-                    output,
-                    "copy" + typeName,
-                    "<BeanType extends " + typeName + "> void",
-                    ObjectModelJavaModifier.STATIC,
-                    ObjectModelJavaModifier.PUBLIC
-            );
-            addParameter(operation, "BeanType", "source");
-            addParameter(operation, "BeanType", "target");
-            addParameter(operation, "Binder<BeanType, BeanType>", "binder");
-            setOperationBody(operation, ""
+        );
+
+        operation = addOperation(
+                output,
+                "copy" + typeName,
+                "<BeanType extends " + typeName + "> void",
+                ObjectModelJavaModifier.STATIC,
+                ObjectModelJavaModifier.PUBLIC
+        );
+        addParameter(operation, "BeanType", "source");
+        addParameter(operation, "BeanType", "target");
+        addParameter(operation, "Binder<BeanType, BeanType>", "binder");
+        setOperationBody(operation, ""
     /*{
         binder.copy(source, target);
     }*/
-            );
+        );
 
-            if (generatePredicates) {
-                generatePredicates(aClass, output, typeName);
-            }
-
-            if (generateFunctions) {
-                generateFunctions(aClass, output, typeName);
-            }
-        }
     }
 
-    @Override
-    protected String getAttributeType(ObjectModelAttribute attr) {
-        String attrType = super.getAttributeType(attr);
-        if (!JavaGeneratorUtil.isPrimitiveType(attrType)) {
-
-            boolean hasClass = model.hasClass(attrType);
-            if (hasClass) {
-                ObjectModelClass attributeClass = model.getClass(attrType);
-                String packageName = attributeClass.getPackageName();
-                ObjectModelPackage attributePackage = model.getPackage(packageName);
-                if (JavaTemplatesStereoTypes.hasBeanStereotype(attributeClass, attributePackage)) {
-
-                    String classNamePrefix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceClassNamePrefixTagValue(attributeClass, attributePackage, model);
-                    String classNameSuffix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceClassNameSuffixTagValue(attributeClass, attributePackage, model);
-
-                    String simpleType = JavaGeneratorUtil.getSimpleName(attrType);
-                    attrType = generateName(classNamePrefix, simpleType, classNameSuffix);
+    protected void generateAbstractBeanDefaultsPredicates(ObjectModelClass input, ObjectModelClass output, String typeName) {
 
-                }
-            }
-
-        }
-        return attrType;
-    }
-
-    protected void generatePredicates(ObjectModelClass input, ObjectModelClass output, String typeName) {
-
-        boolean atLeastOnePropertyfound=false;
+        boolean atLeastOnePropertyFound = false;
         for (ObjectModelAttribute attribute : getProperties(input)) {
 
             boolean multiple = JavaGeneratorUtil.isNMultiplicity(attribute);
@@ -459,7 +429,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
                 continue;
             }
 
-            atLeastOnePropertyfound = true;
+            atLeastOnePropertyFound = true;
             String attrName = getAttributeName(attribute);
             String attrType = getAttributeType(attribute);
             addImport(output, attrType);
@@ -467,7 +437,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
             String simpleType = JavaGeneratorUtil.getSimpleName(attrType);
 
             String capitalizeAttrName = JavaGeneratorUtil.capitalizeJavaBeanPropertyName(attrName);
-            String newPreficateMethodName= "new" + capitalizeAttrName + "Predicate";
+            String newPreficateMethodName = "new" + capitalizeAttrName + "Predicate";
             ObjectModelOperation operation = addOperation(
                     output,
                     newPreficateMethodName,
@@ -477,7 +447,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
             );
             addParameter(operation, simpleType, attrName);
 
-            String getterName = getGetterName(attrName, attribute);
+            String getterName = getGetterName(attribute, attrName);
             setOperationBody(operation, ""
     /*{
         final <%=simpleType%> $tmp = <%=attrName%>;
@@ -508,7 +478,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
             );
         }
 
-        if (atLeastOnePropertyfound) {
+        if (atLeastOnePropertyFound) {
             addImport(output, Predicate.class);
             addImport(output, Objects.class);
             addImport(output, Iterable.class);
@@ -517,9 +487,9 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
 
     }
 
-    protected void generateFunctions(ObjectModelClass input, ObjectModelClass output, String typeName) {
+    protected void generateAbstractBeanDefaultsFunctions(ObjectModelClass input, ObjectModelClass output, String typeName) {
 
-        boolean atLeastOnePropertyfound = false;
+        boolean atLeastOnePropertyFound = false;
         for (ObjectModelAttribute attribute : getProperties(input)) {
 
             boolean multiple = JavaGeneratorUtil.isNMultiplicity(attribute);
@@ -528,7 +498,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
                 continue;
             }
 
-            atLeastOnePropertyfound = true;
+            atLeastOnePropertyFound = true;
 
             String attrName = getAttributeName(attribute);
             String attrType = getAttributeType(attribute);
@@ -537,8 +507,8 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
             String simpleType = JavaGeneratorUtil.getSimpleName(attrType);
             simpleType = wrapPrimitiveType(simpleType);
             String capitalizeAttrName = JavaGeneratorUtil.capitalizeJavaBeanPropertyName(attrName);
-            String newFunctionMethodName= "new" + capitalizeAttrName + "Function";
-            String newFunctionTypeName= "Function<BeanType, " + simpleType + ">";
+            String newFunctionMethodName = "new" + capitalizeAttrName + "Function";
+            String newFunctionTypeName = "Function<BeanType, " + simpleType + ">";
 
             ObjectModelOperation operation = addOperation(
                     output,
@@ -548,7 +518,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
                     ObjectModelJavaModifier.PUBLIC
             );
 
-            String getterName = getGetterName(attrName, attribute);
+            String getterName = getGetterName(attribute, attrName);
             setOperationBody(operation, ""
     /*{
         return new <%=newFunctionTypeName%>() {
@@ -588,7 +558,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
             );
         }
 
-        if (atLeastOnePropertyfound) {
+        if (atLeastOnePropertyFound) {
             addImport(output, Function.class);
             addImport(output, Objects.class);
             addImport(output, ImmutableMap.class);
@@ -598,59 +568,47 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr
 
     }
 
-    protected String wrapPrimitiveType(String attrType) {
-        if (JavaGeneratorUtil.isPrimitiveType(attrType)) {
-            attrType = JavaGeneratorUtil.getPRimitiveWrapType(attrType);
-        }
-        return attrType;
-    }
+    protected String getAbstractDefaultsSuperClassName(ObjectModelPackage aPackage, ObjectModelClass aClass) {
+        String superClassName = null;
 
-    private String getGetterName(String attrName, ObjectModelAttribute attribute) {
-        boolean booleanProperty = JavaGeneratorUtil.isBooleanPrimitive(attribute);
-        String methodPrefix = JavaGeneratorUtil.OPERATION_GETTER_DEFAULT_PREFIX;
-        if (booleanProperty) {
-            methodPrefix = JavaGeneratorUtil.OPERATION_GETTER_BOOLEAN_PREFIX;
+        // test if a super class has bean stereotype
+        boolean superClassIsBean = false;
+        Collection<ObjectModelClass> superclasses = aClass.getSuperclasses();
+        if (CollectionUtils.isNotEmpty(superclasses)) {
+            for (ObjectModelClass superclass : superclasses) {
+                superClassIsBean = beanDefaultClasses.contains(superclass);
+                if (superClassIsBean) {
+                    superClassName = beanDefaultsNameTranslation.get(superclass);
+                    break;
+                }
+                superClassName = superclass.getQualifiedName();
+            }
         }
-        String getterName = getJavaBeanMethodName(methodPrefix, attrName);
-        return getterName;
-    }
 
-//    protected Collection<ObjectModelOperation> getPublicOperations(ObjectModelClass clazz) {
-//
-//        Collection<ObjectModelOperation> result = new ArrayList<ObjectModelOperation>();
-//        for (ObjectModelOperation operation : clazz.getOperations()) {
-//
-//            ObjectModelJavaModifier visibility = ObjectModelJavaModifier.fromVisibility(operation.getVisibility());
-//            if (ObjectModelJavaModifier.PUBLIC == visibility) {
-//                result.add(operation);
-//            }
-//        }
-//        return result;
-//    }
-
-    protected String getBeanClassName(ObjectModelPackage aPackage, ObjectModelClass input) {
-        String classNamePrefix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceClassNamePrefixTagValue(input, aPackage, model);
-        String classNameSuffix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceClassNameSuffixTagValue(input, aPackage, model);
-
-        return generateName(classNamePrefix, input.getName(), classNameSuffix);
-    }
+        if (!superClassIsBean) {
 
-    protected String getBeanDefaultsClassName(ObjectModelPackage aPackage, ObjectModelClass input) {
-        String classNamePrefix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceDefaultsClassNamePrefixTagValue(input, aPackage, model);
-        String classNameSuffix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceDefaultsClassNameSuffixTagValue(input, aPackage, model);
-        return generateName(classNamePrefix, input.getName(), classNameSuffix);
-    }
+            // try to find a super class by tag-value
+            superClassName = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceDefaultsSuperClassTagValue(aClass, aPackage, model);
 
-    protected String generateName(String prefix, String name, String suffix) {
-        StringBuilder sb = new StringBuilder();
-        if (StringUtils.isNotEmpty(prefix)) {
-            sb.append(prefix);
         }
-        sb.append(name);
-        if (StringUtils.isNotEmpty(suffix)) {
-            sb.append(suffix);
+        return superClassName;
+    }
+
+    @Override
+    protected String getAttributeType(ObjectModelAttribute attr) {
+        String attrType = super.getAttributeType(attr);
+        if (!JavaGeneratorUtil.isPrimitiveType(attrType)) {
+            boolean hasClass = model.hasClass(attrType);
+            if (hasClass) {
+                ObjectModelClass attributeClass = model.getClass(attrType);
+                String attributeType = beanNameTranslation.get(attributeClass);
+                if (attributeType != null) {
+                    attrType = attributeType;
+                }
+            }
         }
-        return sb.toString();
+        return attrType;
     }
+
 }
 
diff --git a/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java b/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java
index 3e5ada9..28293a3 100644
--- a/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java
+++ b/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java
@@ -163,7 +163,7 @@ public class GeneratorUtil {
      * @return the wrap primitive type
      * @since 3.0
      */
-    public static String getPRimitiveWrapType(String type) {
+    public static String getPrimitiveWrapType(String type) {
         if ("byte".equals(type)) {
             return "Byte";
         }

-- 
To stop receiving notification emails like this one, please contact
nuiton.org SCM administrator <admin+scm@nuiton.org>.

    

[Eugene-commits] 01/01: Improve some generation code

nuiton.org scm