Author: bleny Date: 2010-08-11 19:09:14 +0200 (Wed, 11 Aug 2010) New Revision: 247 Url: http://nuiton.org/repositories/revision/wikitty/247 Log: breaking single transformer to multiple transformers + utility class Added: branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyContractGenerator.java branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyGeneratorUtil.java branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyHelperGenerator.java branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyImplementationGenerator.java Modified: branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyMetaGenerator.java Added: branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java =================================================================== --- branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java (rev 0) +++ branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java 2010-08-11 17:09:14 UTC (rev 247) @@ -0,0 +1,224 @@ +package org.nuiton.wikitty.generator; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Random; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.eugene.java.ObjectModelTransformerToJava; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelModifier; +import org.nuiton.eugene.models.object.ObjectModelOperation; + +/** + * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.wikitty.generator.WikittyAbstractGenerator" + */ +public class WikittyAbstractGenerator extends ObjectModelTransformerToJava { + + private static final Log log = LogFactory.getLog(WikittyAbstractGenerator.class); + + @Override + public void transformFromClass(ObjectModelClass clazz) { + ObjectModelClass abstractClass = createAbstractClass(clazz.getName() + "Abstract", clazz.getPackageName()); + + // TODO 20100811 bleny remove unused imports + addImport(abstractClass, WikittyGeneratorUtil.BUSINESS_ENTITY_CLASS_FQN); + addImport(abstractClass, WikittyGeneratorUtil.BUSINESS_ENTITY_WIKITTY_CLASS_FQN); + addImport(abstractClass, WikittyGeneratorUtil.WIKITTY_CLASS_FQN); + addImport(abstractClass, "org.nuiton.wikitty.WikittyExtension"); + addImport(abstractClass, "org.nuiton.wikitty.WikittyUtil"); + addImport(abstractClass, "org.nuiton.wikitty.WikittyUser"); + addImport(abstractClass, "org.nuiton.wikitty.WikittyUserAbstract"); + addImport(abstractClass, "org.nuiton.wikitty.WikittyUserImpl"); + addImport(abstractClass, "org.nuiton.wikitty.TreeNode"); + addImport(abstractClass, "org.nuiton.wikitty.TreeNodeAbstract"); + addImport(abstractClass, "org.nuiton.wikitty.TreeNodeImpl"); + addImport(abstractClass, java.util.List.class); + addImport(abstractClass, java.util.ArrayList.class); + addImport(abstractClass, java.util.Collection.class); + addImport(abstractClass, java.util.Collections.class); + addImport(abstractClass, java.util.Set.class); + addImport(abstractClass, java.util.Date.class); + + addInterface(abstractClass, clazz.getQualifiedName()); + + Collection<ObjectModelClass> superClasses = clazz.getSuperclasses(); + if (superClasses.isEmpty()) { + // no inheritance so inheritance from BusinessEntityWikitty + setSuperClass(abstractClass, "BusinessEntityWikitty"); + } else { + for (ObjectModelClass superClass : superClasses) { + // using "for" but there will be 0 or 1 iteration + addInterface(abstractClass, superClass.getQualifiedName()); + setSuperClass(abstractClass, superClass.getQualifiedName() + "Impl"); + } + } + + // adding a generated serialVersionUID + Random random = new Random(); + Long serialVersionUIDs = random.nextLong(); + addConstant(abstractClass, + "serialVersionUID", + "long", + serialVersionUIDs.toString() + "L", + ObjectModelModifier.PRIVATE); + + ObjectModelOperation constructor = addConstructor(abstractClass, ObjectModelModifier.PUBLIC); + setOperationBody(constructor, "" +/*{ + super(); +}*/); + + constructor = addConstructor(abstractClass, ObjectModelModifier.PUBLIC); + addParameter(constructor, WikittyGeneratorUtil.WIKITTY_CLASS_FQN, "wikitty"); + setOperationBody(constructor, "" +/*{ + super(wikitty); +}*/); + + constructor = addConstructor(abstractClass, ObjectModelModifier.PUBLIC); + addParameter(constructor, WikittyGeneratorUtil.BUSINESS_ENTITY_WIKITTY_CLASS_FQN, "businessEntityWikitty"); + setOperationBody(constructor, "" +/*{ + super(businessEntityWikitty.getWikitty()); +}*/); + + + // adding some constants about extension to abstract + addConstant(abstractClass, "extensions", "List<WikittyExtension>", null, ObjectModelModifier.PUBLIC); + addConstant(abstractClass, "extension" + clazz.getName(), "WikittyExtension", null, ObjectModelModifier.PUBLIC); + + // ... and a getter + ObjectModelOperation getStaticExtensions = addOperation(abstractClass, "getStaticExtensions", "Collection<WikittyExtension>", ObjectModelModifier.PUBLIC); + addAnnotation(abstractClass, getStaticExtensions, "Override"); + setOperationBody(getStaticExtensions, "" +/*{ + return extensions; +}*/); + + + //// preparing static equals(w1, w2) + + ObjectModelOperation equals = addOperation(abstractClass, "equals", "boolean", ObjectModelModifier.STATIC); + addParameter(equals, WikittyGeneratorUtil.WIKITTY_CLASS_FQN, "w1"); + addParameter(equals, WikittyGeneratorUtil.WIKITTY_CLASS_FQN, "w2"); + + // the body of the equals method, will be assembled while reading attributes + String equalsBody = "" +/*{ + boolean result = true; +}*/; + String extensionVariableName = WikittyGeneratorUtil.classToExtensionVariableName(clazz); + for(ObjectModelAttribute attribute : clazz.getAttributes()) { + if (attribute.isNavigable()) { + // two variables needed below + // String fieldVariableName = "FIELD_" + clazz.getName().toUpperCase() + "_" + attribute.getName().toUpperCase(); + String fieldVariableName = WikittyGeneratorUtil.attributeToFielVariableName(attribute); + + // considering field in equals body + equalsBody += "" +/*{ + if (result) { + Object f1 = w1.getFieldAsObject(<%= extensionVariableName %>, <%= fieldVariableName %>); + Object f2 = w2.getFieldAsObject(<%= extensionVariableName %>, <%= fieldVariableName %>); + result = f1 == f2 || (f1 != null && f1.equals(f2)); + }; +}*/; + } + } + + // finishing equals body + equalsBody += "" +/*{ + return result; +}*/; + setOperationBody(equals, equalsBody); + + + //// preparing a static block to initialize those constants + ObjectModelOperation staticInitialization = addBlock(abstractClass, ObjectModelModifier.STATIC); + + // generating constructor call for extensionClient + // we will build a string to write a call + List<String> buildFieldMapExtensionParameters = new ArrayList<String>(); + + + + // now process attributes + for(ObjectModelAttribute attribute : clazz.getAttributes()) { + if (attribute.isNavigable()) { + // now add the attribute to the piece of code that build the extension + String wikittyType = WikittyGeneratorUtil.typeToWikittyColumn(attribute.getType()); + String multiplicity = ""; + if (attribute.getMinMultiplicity() != 1 || + attribute.getMaxMultiplicity() != 1) { + // generate a string like [1-10] or [0-*] etc. + multiplicity = "[" + + attribute.getMinMultiplicity() + + "-" + + (attribute.getMaxMultiplicity() == -1 ? "*" : attribute.getMaxMultiplicity()) + + "]"; + } + + // generate a string line like " unique=true" or "" + String unique = attribute.isUnique() ? " unique=true" : ""; + // generate a string line like " deprecated=true" or "" + String deprecated = attribute.hasTagValue("deprecated") ? " deprecated=" + attribute.getTagValue("deprecated") : ""; + // generate a string line like ' documentation="my documentation"' or "" + String attributeDocumentation = attribute.hasTagValue("documentation") ? " documentation=\\\"" + attribute.getTagValue("documentation") + "\\\"": ""; + // generate a string like " notNull=true" or "" + String notNull = attribute.hasTagValue("notNull") ? " notNull=" + attribute.getTagValue("notNull") : ""; + buildFieldMapExtensionParameters.add("" // generate a line like '"Wikitty attributName[0-*] unique=true deprecated=true documentation=\"my documentation\""' +/*{ "<%=wikittyType%> <%=attribute.getName()%><%=multiplicity%><%=unique%><%=deprecated%><%=notNull%><%=attributeDocumentation%>"}*/); + } + } + + // finishing static block + String extensionVersion = clazz.getTagValue("version"); + if (extensionVersion == null || "".equals(extensionVersion)) { + extensionVersion = "0.1"; + log.warn("no version specified in model for " + clazz.getQualifiedName() + " using " + extensionVersion); + } + + // a piece of code used in the static block + String requires = null; + for (ObjectModelClass superClass : superClasses) { + // using "for" but there will be 0 or 1 iteration + requires = superClass.getName() + "." + WikittyGeneratorUtil.classToExtensionVariableName(superClass); + } + + String staticInitializationBody = "" +/*{ + extension<%=clazz.getName()%> = + new WikittyExtension(EXT_<%=clazz.getName().toUpperCase()%>, + "<%=extensionVersion%>", // version + <%= requires %>, + WikittyUtil.buildFieldMapExtension( // building field map +<%=StringUtils.join(buildFieldMapExtensionParameters, ", \n")%>)); + + // init extensions + List<WikittyExtension> exts = new ArrayList<WikittyExtension>(); +}*/; + + for (ObjectModelClass superClass : superClasses) { + // using "for" but there will be 0 or 1 iteration + staticInitializationBody += "" +/*{ + exts.addAll(<%=superClass.getName()%>Abstract.extensions); + // current after requires ones +}*/; + } + + staticInitializationBody += "" +/*{ + exts.add(extension<%=clazz.getName()%>); + extensions = Collections.unmodifiableList(exts); +}*/; + setOperationBody(staticInitialization, staticInitializationBody); + + } + +} Added: branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyContractGenerator.java =================================================================== --- branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyContractGenerator.java (rev 0) +++ branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyContractGenerator.java 2010-08-11 17:09:14 UTC (rev 247) @@ -0,0 +1,84 @@ +package org.nuiton.wikitty.generator; + +import java.util.Collection; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.eugene.java.ObjectModelTransformerToJava; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelInterface; +import org.nuiton.eugene.models.object.ObjectModelModifier; + +/** + * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.wikitty.generator.WikittyContractGenerator" + */ +public class WikittyContractGenerator extends ObjectModelTransformerToJava { + + private static final Log log = LogFactory.getLog(WikittyContractGenerator.class); + + @Override + public void transformFromClass(ObjectModelClass clazz) { + + ObjectModelInterface contract = createInterface(clazz.getName(), clazz.getPackageName()); + addInterface(contract, WikittyGeneratorUtil.BUSINESS_ENTITY_CLASS_FQN); + + // TODO 20100811 bleny remove unused imports + addImport(contract, WikittyGeneratorUtil.BUSINESS_ENTITY_CLASS_FQN); + addImport(contract, WikittyGeneratorUtil.BUSINESS_ENTITY_WIKITTY_CLASS_FQN); + addImport(contract, WikittyGeneratorUtil.WIKITTY_CLASS_FQN); + addImport(contract, "org.nuiton.wikitty.WikittyExtension"); + addImport(contract, "org.nuiton.wikitty.WikittyUtil"); + addImport(contract, "org.nuiton.wikitty.WikittyUser"); + addImport(contract, "org.nuiton.wikitty.WikittyUserAbstract"); + addImport(contract, "org.nuiton.wikitty.WikittyUserImpl"); + addImport(contract, "org.nuiton.wikitty.TreeNode"); + addImport(contract, "org.nuiton.wikitty.TreeNodeAbstract"); + addImport(contract, "org.nuiton.wikitty.TreeNodeImpl"); + addImport(contract, java.util.List.class); + addImport(contract, java.util.ArrayList.class); + addImport(contract, java.util.Collection.class); + addImport(contract, java.util.Collections.class); + addImport(contract, java.util.Set.class); + addImport(contract, java.util.Date.class); + + Collection<ObjectModelClass> superClasses = clazz.getSuperclasses(); + if (! superClasses.isEmpty()) { + for (ObjectModelClass superClass : superClasses) { + // using "for" but there will be 0 or 1 iteration + addInterface(contract, superClass.getQualifiedName()); + } + } + + // adding public static final String EXT_CLIENT = "Client"; + addConstant(contract, + "EXT_" + clazz.getName().toUpperCase(), + "String", + "\"" + clazz.getName() + "\"", + ObjectModelModifier.PUBLIC); + + String extensionVariableName = WikittyGeneratorUtil.classToExtensionVariableName(clazz); + + for(ObjectModelAttribute attribute : clazz.getAttributes()) { + if (attribute.isNavigable()) { + // two variables needed below + String fieldVariableName = WikittyGeneratorUtil.attributeToFielVariableName(attribute); + + // adding constants to contract + addConstant(contract, + fieldVariableName, + "String", + "\"" + attribute.getName() + "\"", + ObjectModelModifier.PUBLIC); + // adding public static final String FQ_FIELD_CLIENT_NAME = EXT_CLIENT + ".name"; + addConstant(contract, + "FQ_" + fieldVariableName, + "String", + extensionVariableName + " + \"." + attribute.getName() + "\"", + ObjectModelModifier.PUBLIC); + } + } + } + +} Added: branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyGeneratorUtil.java =================================================================== --- branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyGeneratorUtil.java (rev 0) +++ branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyGeneratorUtil.java 2010-08-11 17:09:14 UTC (rev 247) @@ -0,0 +1,96 @@ +package org.nuiton.wikitty.generator; + +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; + + +public class WikittyGeneratorUtil { + + /** utility class should not be instanciated */ + private WikittyGeneratorUtil() {} + + protected static final String BUSINESS_ENTITY_CLASS_FQN = "org.nuiton.wikitty.BusinessEntity"; + protected static final String BUSINESS_ENTITY_WIKITTY_CLASS_FQN = "org.nuiton.wikitty.BusinessEntityWikitty"; + protected static final String WIKITTY_CLASS_FQN = "org.nuiton.wikitty.Wikitty"; + + /** given a class called Client will return "EXT_CLIENT" + * should be used as a variable name to store the extension name + */ + protected static String classToExtensionVariableName(ObjectModelClass clazz) { + String extensionVariableName = "EXT_" + clazz.getName().toUpperCase(); + return extensionVariableName; + } + + /** given the field name of the class client, will return FIELD_CLIENT_NAME */ + protected static String attributeToFielVariableName(ObjectModelAttribute attribute) { + String fieldVariableName = "FIELD_" + attribute.getDeclaringElement().getName().toUpperCase() + "_" + attribute.getName().toUpperCase(); + return fieldVariableName; + } + + /** given "my.java.package.MyClass" or "MyClass" return "MyClass" */ + protected static String FQNtoSimpleName(String fqn) { + int lastDotIndex = fqn.lastIndexOf("."); + String simpleName = fqn; + if (lastDotIndex != -1) { + simpleName = fqn.substring(lastDotIndex + 1); + } + return simpleName; + } + + /** + * wikitty interface provide getFieldAsString, getFieldAsDate etc. methods + * this method returns the good name of the method to call depending the + * type given as parameter + * @param typeName a name of a business entity or "String", "Integer" etc. + * @return the name of a method "getFieldAsInt" for example + */ + protected static String generateGetFieldAsCall(String typeName) { + String asWhat = FQNtoSimpleName(typeName); + if ("boolean".equals(asWhat)) { + asWhat = "Boolean"; + } else if ("int".equals(asWhat) || "Integer".equals(asWhat)) { + asWhat = "Int"; + } else if ("Date".equals(asWhat)) { + // asWhat = "Date"; + } else { + asWhat = "String"; + } + return "getFieldAs" + asWhat; + } + + + protected static String generateResultType(String typeName) { + String asWhat = FQNtoSimpleName(typeName); + if ("boolean".equals(asWhat)) { + // asWhat = "boolean"; + } else if ("int".equals(asWhat) || "Integer".equals(asWhat)) { + // asWhat = "Int"; + } else if ("Date".equals(asWhat)) { + // asWhat = "Date"; + } else { + asWhat = "String"; + } + return asWhat; + } + + protected static String typeToWikittyColumn(String type) { + String simpleType = FQNtoSimpleName(type); + String result = null; + if ("Date".equals(simpleType)) { + result = "Date"; + } else if ("String".equals(simpleType)) { + result = "String"; + } else if ("boolean".equals(simpleType)) { + result = "boolean"; + } else if ("int".equals(simpleType) || + "Integer".equals(simpleType)) { + result = "Numeric"; + } else { + result = "Wikitty"; + } + return result; + } + + + +} Added: branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyHelperGenerator.java =================================================================== --- branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyHelperGenerator.java (rev 0) +++ branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyHelperGenerator.java 2010-08-11 17:09:14 UTC (rev 247) @@ -0,0 +1,44 @@ +package org.nuiton.wikitty.generator; + +import org.nuiton.eugene.java.ObjectModelTransformerToJava; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelModifier; +import org.nuiton.eugene.models.object.ObjectModelOperation; + +/** + * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.wikitty.generator.WikittyHelperGenerator" + */ +public class WikittyHelperGenerator extends ObjectModelTransformerToJava { + + @Override + public void transformFromClass(ObjectModelClass clazz) { + + ObjectModelClass helper = createClass(clazz.getName() + "Helper", clazz.getPackageName()); + + // TODO 20100811 bleny remove unused imports + addImport(helper, WikittyGeneratorUtil.BUSINESS_ENTITY_CLASS_FQN); + addImport(helper, WikittyGeneratorUtil.BUSINESS_ENTITY_WIKITTY_CLASS_FQN); + addImport(helper, WikittyGeneratorUtil.WIKITTY_CLASS_FQN); + addImport(helper, "org.nuiton.wikitty.WikittyExtension"); + addImport(helper, "org.nuiton.wikitty.WikittyUtil"); + addImport(helper, "org.nuiton.wikitty.WikittyUser"); + addImport(helper, "org.nuiton.wikitty.WikittyUserAbstract"); + addImport(helper, "org.nuiton.wikitty.WikittyUserImpl"); + addImport(helper, "org.nuiton.wikitty.TreeNode"); + addImport(helper, "org.nuiton.wikitty.TreeNodeAbstract"); + addImport(helper, "org.nuiton.wikitty.TreeNodeImpl"); + addImport(helper, java.util.List.class); + addImport(helper, java.util.ArrayList.class); + addImport(helper, java.util.Collection.class); + addImport(helper, java.util.Collections.class); + addImport(helper, java.util.Set.class); + addImport(helper, java.util.Date.class); + + // provides interface constants for to the helper + setSuperClass(helper, clazz.getQualifiedName() + "Impl"); + + // making constructor for helper class (empty and private) + ObjectModelOperation constructor = addConstructor(helper, ObjectModelModifier.PRIVATE); + setOperationBody(constructor, "\n// utility class\n"); // empty implementation + } +} Added: branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyImplementationGenerator.java =================================================================== --- branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyImplementationGenerator.java (rev 0) +++ branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyImplementationGenerator.java 2010-08-11 17:09:14 UTC (rev 247) @@ -0,0 +1,71 @@ +package org.nuiton.wikitty.generator; + +import java.util.Random; + +import org.nuiton.eugene.java.ObjectModelTransformerToJava; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelModifier; +import org.nuiton.eugene.models.object.ObjectModelOperation; + +/** + * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.wikitty.generator.WikittyImplementationGenerator" + */ +public class WikittyImplementationGenerator extends ObjectModelTransformerToJava { + + @Override + public void transformFromClass(ObjectModelClass clazz) { + ObjectModelClass implementation = createClass(clazz.getName() + "Impl", clazz.getPackageName()); + + // TODO 20100811 bleny remove unused imports + addImport(implementation, WikittyGeneratorUtil.BUSINESS_ENTITY_CLASS_FQN); + addImport(implementation, WikittyGeneratorUtil.BUSINESS_ENTITY_WIKITTY_CLASS_FQN); + addImport(implementation, WikittyGeneratorUtil.WIKITTY_CLASS_FQN); + addImport(implementation, "org.nuiton.wikitty.WikittyExtension"); + addImport(implementation, "org.nuiton.wikitty.WikittyUtil"); + addImport(implementation, "org.nuiton.wikitty.WikittyUser"); + addImport(implementation, "org.nuiton.wikitty.WikittyUserAbstract"); + addImport(implementation, "org.nuiton.wikitty.WikittyUserImpl"); + addImport(implementation, "org.nuiton.wikitty.TreeNode"); + addImport(implementation, "org.nuiton.wikitty.TreeNodeAbstract"); + addImport(implementation, "org.nuiton.wikitty.TreeNodeImpl"); + addImport(implementation, java.util.List.class); + addImport(implementation, java.util.ArrayList.class); + addImport(implementation, java.util.Collection.class); + addImport(implementation, java.util.Collections.class); + addImport(implementation, java.util.Set.class); + addImport(implementation, java.util.Date.class); + + setSuperClass(implementation, clazz.getQualifiedName() + "Abstract"); + + // adding constructor + ObjectModelOperation constructor = addConstructor(implementation, ObjectModelModifier.PUBLIC); + setOperationBody(constructor, "" +/*{ + super(); +}*/); + + constructor = addConstructor(implementation, ObjectModelModifier.PUBLIC); + addParameter(constructor, WikittyGeneratorUtil.WIKITTY_CLASS_FQN, "wikitty"); + setOperationBody(constructor, "" +/*{ + super(wikitty); +}*/); + + constructor = addConstructor(implementation, ObjectModelModifier.PUBLIC); + addParameter(constructor, WikittyGeneratorUtil.BUSINESS_ENTITY_WIKITTY_CLASS_FQN, "businessEntityWikitty"); + setOperationBody(constructor, "" +/*{ + super(businessEntityWikitty.getWikitty()); +}*/); + + // adding a generated serialVersionUID + Random random = new Random(); + Long serialVersionUIDs = random.nextLong(); + addConstant(implementation, + "serialVersionUID", + "long", + serialVersionUIDs.toString() + "L", + ObjectModelModifier.PRIVATE); + } + +} Modified: branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyMetaGenerator.java =================================================================== --- branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyMetaGenerator.java 2010-08-11 15:27:25 UTC (rev 246) +++ branches/wikitty-eugene-migration/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyMetaGenerator.java 2010-08-11 17:09:14 UTC (rev 247) @@ -8,7 +8,11 @@ import org.apache.commons.lang.StringUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.nuiton.eugene.AbstractMetaTransformer; +import org.nuiton.eugene.TemplateConfiguration; +import org.nuiton.eugene.Transformer; import org.nuiton.eugene.java.ObjectModelTransformerToJava; +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.ObjectModelClassifier; @@ -23,483 +27,208 @@ * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.wikitty.generator.WikittyMetaGenerator" */ - // TODO 20100610 use filter with /*[]*/ /*{generator option: writeString = }*/ /*{generator option: parentheses = false}*/ /*{generator option: writeString = +}*/ // TODO 20100609 bleny break this transformer in more specialized transformer, WikittyMetaGenerator will manage all those transformers -public class WikittyMetaGenerator extends ObjectModelTransformerToJava { - +public class WikittyMetaGenerator extends AbstractMetaTransformer<ObjectModel> { + private static final Log log = LogFactory.getLog(WikittyMetaGenerator.class); - protected static final String BUSINESS_ENTITY_STEREOTYPE_NAME = "entity"; /** @deprecated name change : see ticket #798. use BUSINESS_ENTITY_STEREOTYPE_NAME */ @Deprecated protected static final String BUSINESS_ENTITY_STEREOTYPE_OLD_NAME = "BusinessEntity"; - - - protected static final String BUSINESS_ENTITY_CLASS_FQN = "org.nuiton.wikitty.BusinessEntity"; - protected static final String BUSINESS_ENTITY_WIKITTY_CLASS_FQN = "org.nuiton.wikitty.BusinessEntityWikitty"; - protected static final String WIKITTY_CLASS_FQN = "org.nuiton.wikitty.Wikitty"; - /** current class read from model */ - protected ObjectModelClass clazz; + protected static final String BUSINESS_ENTITY_STEREOTYPE_NAME = "entity"; - /** contract for this business entity */ - protected ObjectModelInterface contract; - - /** abstract class for this business entity */ - protected ObjectModelClass abstractClass; - - /** implementation class for this business entity */ - protected ObjectModelClass implementation; - - /** implementation class for this business entity */ - protected ObjectModelClass helper; - - /** the body of the equals method, will be assembled while reading attributes */ - protected String equalsBody; + public WikittyMetaGenerator() { + super(WikittyContractGenerator.class, + WikittyAbstractGenerator.class, + WikittyImplementationGenerator.class, + WikittyHelperGenerator.class); + } @Override - public void transformFromClass(ObjectModelClass clazz) { + protected boolean validateModel(ObjectModel model) { - this.clazz = clazz; - - Collection<ObjectModelClass> superClasses = clazz.getSuperclasses(); - if (superClasses.size() > 1) { - log.error("Java doesn't support multiple inheritance for class " + clazz.getName()); - return ; + if (model.getClasses().isEmpty()) { + log.warn("model doesn't contains any class"); } - - if (clazz.getStereotypes().contains(BUSINESS_ENTITY_STEREOTYPE_OLD_NAME)) { - log.warn(clazz.getName() + " uses deprecated \"" + BUSINESS_ENTITY_STEREOTYPE_OLD_NAME - +"\" stereotype. use \"" + BUSINESS_ENTITY_STEREOTYPE_NAME + "\" instead"); - } - if (clazz.getStereotypes().contains(BUSINESS_ENTITY_STEREOTYPE_OLD_NAME) - || clazz.getStereotypes().contains(BUSINESS_ENTITY_STEREOTYPE_NAME)) { - // for a single business entity, we create a contract, an abstract and an implementation - contract = createInterface(clazz.getName(), clazz.getPackageName()); - abstractClass = createAbstractClass(clazz.getName() + "Abstract", clazz.getPackageName()); - implementation = createClass(clazz.getName() + "Impl", clazz.getPackageName()); - helper = createClass(clazz.getName() + "Helper", clazz.getPackageName()); - - addImports(contract); - addImports(abstractClass); - addImports(implementation); - addImports(helper); - - // now, deal with inheritance - - // implementation extends abstract and abstract realizes contract - addInterface(contract, BUSINESS_ENTITY_CLASS_FQN); - addInterface(abstractClass, contract.getQualifiedName()); - setSuperClass(implementation, abstractClass.getQualifiedName()); - setSuperClass(helper, implementation.getQualifiedName()); // as it was in the old templates - - // dealing with inheritance between entities specified in the model - if (superClasses.isEmpty()) { - // no inheritance so inheritance from BusinessEntityWikitty - setSuperClass(abstractClass, "BusinessEntityWikitty"); - } else { - for (ObjectModelClass superClass : superClasses) { - // using "for" but there will be 0 or 1 iteration - addInterface(contract, superClass.getQualifiedName()); - addInterface(abstractClass, superClass.getQualifiedName()); - setSuperClass(abstractClass, superClass.getQualifiedName() + "Impl"); - } + for (ObjectModelClass clazz : model.getClasses()) { + if (clazz.getSuperclasses().size() > 1) { + log.error("multiple inheritance for class " + clazz.getName()); + return false; } - - // adding public static final String EXT_CLIENT = "Client"; - addConstant(contract, - "EXT_" + clazz.getName().toUpperCase(), - "String", - "\"" + clazz.getName() + "\"", - ObjectModelModifier.PUBLIC); - - // adding serialVersionUIDs - Random random = new Random(); - Long serialVersionUIDs = random.nextLong(); - addConstant(abstractClass, - "serialVersionUID", - "long", - serialVersionUIDs.toString() + "L", - ObjectModelModifier.PRIVATE); - serialVersionUIDs = random.nextLong(); - addConstant(implementation, - "serialVersionUID", - "long", - serialVersionUIDs.toString() + "L", - ObjectModelModifier.PRIVATE); - // making constructors for abstract and implementation (both are same) - addConstructors(abstractClass); - addConstructors(implementation); - - // making constructor for helper class (empty and private) - ObjectModelOperation constructor = addConstructor(helper, ObjectModelModifier.PRIVATE); - setOperationBody(constructor, "\n// utility class\n"); // empty implementation - - // adding some constants about extension to abstract - addConstant(abstractClass, "extensions", "List<WikittyExtension>", null, ObjectModelModifier.PUBLIC); - addConstant(abstractClass, "extension" + clazz.getName(), "WikittyExtension", null, ObjectModelModifier.PUBLIC); - - // ... and a getter - ObjectModelOperation getStaticExtensions = addOperation(abstractClass, "getStaticExtensions", "Collection<WikittyExtension>", ObjectModelModifier.PUBLIC); - setOperationBody(getStaticExtensions, "" -/*{ - return extensions; -}*/); - addAnnotation(abstractClass, getStaticExtensions, "Override"); - - // preparing a static block to initialize those constants - ObjectModelOperation staticInitialization = addBlock(abstractClass, ObjectModelModifier.STATIC); - - // generating constructor call for extensionClient - // we will build a string to write a call - List<String> buildFieldMapExtensionParameters = new ArrayList<String>(); - - // preparing static equals(w1, w2) - ObjectModelOperation equals = addOperation(abstractClass, "equals", "boolean", ObjectModelModifier.STATIC); - addParameter(equals, WIKITTY_CLASS_FQN, "w1"); - addParameter(equals, WIKITTY_CLASS_FQN, "w2"); - equalsBody = "" -/*{ - boolean result = true; -}*/; - - // now process attributes - for(ObjectModelAttribute attribute : clazz.getAttributes()) { - if (attribute.isNavigable()) { - processAttribute(attribute); - - // equalsBody will be updated in processAttribute - buildFieldMapExtensionParameters.add("\"" + attribute.getType() + " " + attribute.getName() + "\""); - - } + if (clazz.getStereotypes().contains(BUSINESS_ENTITY_STEREOTYPE_OLD_NAME)) { + log.warn(clazz.getQualifiedName() + " uses deprecated \"" + BUSINESS_ENTITY_STEREOTYPE_OLD_NAME + +"\" stereotype. use \"" + BUSINESS_ENTITY_STEREOTYPE_NAME + "\" instead"); } - - // finishing equals body - equalsBody += "" -/*{ - return result; -}*/; - setOperationBody(equals, equalsBody); - - // finishing static block - String extensionVersion = clazz.getTagValue("version"); - if (extensionVersion == null || "".equals(extensionVersion)) { - extensionVersion = "0.1"; - log.warn("no version specified in model for " + clazz.getQualifiedName() + " using " + extensionVersion); - } - - // a piece of code used in the static block - String requires = null; - for (ObjectModelClass superClass : superClasses) { - // using "for" but there will be 0 or 1 iteration - requires = superClass.getName() + ".EXT_" + superClass.getName().toUpperCase(); - } - - String staticInitializationBody = "" - /*{ - extension<%=clazz.getName()%> = - new WikittyExtension(EXT_<%=clazz.getName().toUpperCase()%>, - "<%=extensionVersion%>", // version - <%= requires %>, // - WikittyUtil.buildFieldMapExtension(<%=StringUtils.join(buildFieldMapExtensionParameters, ", \n")%>)); - - // init extensions - List<WikittyExtension> exts = new ArrayList<WikittyExtension>(); - }*/; - - for (ObjectModelClass superClass : superClasses) { - // using "for" but there will be 0 or 1 iteration - staticInitializationBody += "" -/*{ - exts.addAll(<%=superClass.getName()%>Abstract.extensions); - // current after requires ones -}*/; - } - - staticInitializationBody += "" -/*{ - exts.add(extension<%=clazz.getName()%>); - extensions = Collections.unmodifiableList(exts); -}*/; - setOperationBody(staticInitialization, staticInitializationBody); } - } - protected void addImports(ObjectModelClassifier classifier) { - addImport(classifier, BUSINESS_ENTITY_CLASS_FQN); - addImport(classifier, BUSINESS_ENTITY_WIKITTY_CLASS_FQN); - addImport(classifier, WIKITTY_CLASS_FQN); - addImport(classifier, "org.nuiton.wikitty.WikittyExtension"); - addImport(classifier, "org.nuiton.wikitty.WikittyUtil"); - addImport(classifier, "org.nuiton.wikitty.WikittyUser"); - addImport(classifier, "org.nuiton.wikitty.WikittyUserAbstract"); - addImport(classifier, "org.nuiton.wikitty.WikittyUserImpl"); - addImport(classifier, "org.nuiton.wikitty.TreeNode"); - addImport(classifier, "org.nuiton.wikitty.TreeNodeAbstract"); - addImport(classifier, "org.nuiton.wikitty.TreeNodeImpl"); - addImport(classifier, java.util.List.class); - addImport(classifier, java.util.ArrayList.class); - addImport(classifier, java.util.Collection.class); - addImport(classifier, java.util.Collections.class); - addImport(classifier, java.util.Set.class); - addImport(classifier, java.util.Date.class); + return true; } - /** add three constructors : empty, from business entity wikitty, from wikitty */ - protected void addConstructors(ObjectModelClass clazz) { - ObjectModelOperation constructor = addConstructor(clazz, ObjectModelModifier.PUBLIC); - setOperationBody(constructor, "" -/*{ - super(); -}*/); - - constructor = addConstructor(clazz, ObjectModelModifier.PUBLIC); - addParameter(constructor, WIKITTY_CLASS_FQN, "wikitty"); - setOperationBody(constructor, "" -/*{ - super(wikitty); -}*/); - - constructor = addConstructor(clazz, ObjectModelModifier.PUBLIC); - addParameter(constructor, BUSINESS_ENTITY_WIKITTY_CLASS_FQN, "businessEntityWikitty"); - setOperationBody(constructor, "" -/*{ - super(businessEntityWikitty.getWikitty()); -}*/); - } - - - protected void processAttribute(ObjectModelAttribute attribute) { - // two variables needed below - String extensionVariableName = "EXT_" + clazz.getName().toUpperCase(); - String fieldVariableName = "FIELD_" + clazz.getName().toUpperCase() + "_" + attribute.getName().toUpperCase(); - - // adding constants to contract - { - addConstant(contract, - fieldVariableName, - "String", - "\"" + attribute.getName() + "\"", - ObjectModelModifier.PUBLIC); - // adding public static final String FQ_FIELD_CLIENT_NAME = EXT_CLIENT + ".name"; - addConstant(contract, - "FQ_" + fieldVariableName, - "String", - extensionVariableName + " + \"." + attribute.getName() + "\"", - ObjectModelModifier.PUBLIC); - } - - // considering field in equals body - { - equalsBody += "" -/*{ - if (result) { - Object f1 = w1.getFieldAsObject(<%= extensionVariableName %>, <%= fieldVariableName %>); - Object f2 = w2.getFieldAsObject(<%= extensionVariableName %>, <%= fieldVariableName %>); - result = f1 == f2 || (f1 != null && f1.equals(f2)); - }; -}*/; - } - - // let's find a name for the getter - String getterName = getMethodName("get", contract, attribute, attribute.getTagValue("getter")); - - // let's find a name for the setter - String setterName = getMethodName("set", contract, attribute, attribute.getTagValue("setter")); - - // attribute type simple name as it should be in signature - String attributeTypeSimpleName = FQNtoSimpleName(attribute.getType()); - if ("boolean".equals(attributeTypeSimpleName)) { - attributeTypeSimpleName = "Boolean"; - } else if ("int".equals(attributeTypeSimpleName)) { - attributeTypeSimpleName = "Integer"; - } - - if (attribute.getMaxMultiplicity() > 1 || attribute.getMaxMultiplicity() == -1) { - String attributeTypeSimpleNameInSet = "Set<" + attributeTypeSimpleName + ">"; - - // now, for this attribute, we will generate add, remove and clear methods - - // adding operations to contract - ObjectModelOperation getter = addOperation(contract, getterName, attributeTypeSimpleNameInSet); - - String addName = getMethodName("add", contract, attribute, attribute.getTagValue("adder")); - ObjectModelOperation adder = addOperation(contract, addName, "void"); - addParameter(adder, "String", "element"); - - String removeName = getMethodName("remove", contract, attribute, attribute.getTagValue("remover")); - ObjectModelOperation remover = addOperation(contract, removeName, "void"); - addParameter(remover, "String", "element"); - - String clearName = getMethodName("clear", contract, attribute, attribute.getTagValue("clear")); - ObjectModelOperation clear = addOperation(contract, clearName, "void"); - - // adding operations to abstract with bodies - getter = cloneOperationSignature(getter, abstractClass, true, ObjectModelModifier.PUBLIC); - String getterBody = "" -/*{ - <%= attributeTypeSimpleNameInSet %> result = getWikitty().getFieldAsSet(<%= extensionVariableName %>, <%= fieldVariableName %>, <%= attributeTypeSimpleName %>.class); - return result; -}*/; - setOperationBody(getter, getterBody); - - adder = cloneOperationSignature(adder, abstractClass, true, ObjectModelModifier.PUBLIC); - String adderBody = "" -/*{ - getWikitty().addToField(<%=extensionVariableName%>, <%=fieldVariableName%>, element); - getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%= getter.getName() %>()); -}*/; - setOperationBody(adder, adderBody); - - remover = cloneOperationSignature(remover, abstractClass, true, ObjectModelModifier.PUBLIC); - String removerBody = "" -/*{ - getWikitty().removeFromField(<%=extensionVariableName%>, <%=fieldVariableName%>, element); - getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%=getter.getName()%>()); -}*/; - setOperationBody(remover, removerBody); - - clear = cloneOperationSignature(clear, abstractClass, true, ObjectModelModifier.PUBLIC); - String clearBody = "" -/*{ - getWikitty().clearField(<%=extensionVariableName%>, <%=fieldVariableName%>); - getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%=getter.getName()%>()); -}*/; - setOperationBody(clear, clearBody); - - // adding operations to Helper with bodies - getter = addOperation(helper, getterName, attributeTypeSimpleNameInSet, ObjectModelModifier.STATIC); - addParameter(getter, WIKITTY_CLASS_FQN, "wikitty"); - setOperationBody(getter, "" -/*{ - <%=attributeTypeSimpleNameInSet%> result = wikitty.getFieldAsSet(<%=extensionVariableName%>, <%=fieldVariableName%>, <%=attributeTypeSimpleName%>.class); - return result; -}*/); - - adder = addOperation(helper, addName, "void", ObjectModelModifier.STATIC); - addParameter(adder, WIKITTY_CLASS_FQN, "wikitty"); - addParameter(adder, attributeTypeSimpleName, "element"); - setOperationBody(adder, "" -/*{ - wikitty.addToField(<%=extensionVariableName%>, <%=clazz.getName()%>.<%=fieldVariableName%>, element); -}*/ -); - - remover = addOperation(helper, removeName, "void", ObjectModelModifier.STATIC); - addParameter(remover, WIKITTY_CLASS_FQN, "wikitty"); - addParameter(remover, attributeTypeSimpleName, "element"); - setOperationBody(remover, "" -/*{ - wikitty.removeFromField(<%=extensionVariableName%>, <%=clazz.getName()%>.<%=fieldVariableName%>, element); -}*/); - - clear = addOperation(helper, clearName, "void", ObjectModelModifier.STATIC); - addParameter(clear, WIKITTY_CLASS_FQN, "wikitty"); - setOperationBody(clear, "" -/*{ - wikitty.clearField(<%=extensionVariableName%>, <%=clazz.getName()%>.<%=fieldVariableName%>); -}*/); - - } else { - String getFieldMethodName = generateGetFieldAsCall(attribute.getType()); - String resultType = generateResultType(attribute.getType()); - attributeTypeSimpleName = resultType; - - // adding getter and setter to contract - ObjectModelOperation getter = addOperation(contract, getterName, attributeTypeSimpleName); - ObjectModelOperation setter = addOperation(contract, setterName, "void"); - addParameter(setter, attributeTypeSimpleName, attribute.getName()); - - // adding getter and setter to abstract with bodies - getter = cloneOperationSignature(getter, abstractClass, true, ObjectModelModifier.PUBLIC); - setOperationBody(getter, "" -/*{ - <%=resultType%> result = getWikitty().<%=getFieldMethodName%>(<%=extensionVariableName%>, <%=fieldVariableName%>); - return result; -}*/); - - setter = cloneOperationSignature(setter, abstractClass, true, ObjectModelModifier.PUBLIC); - setOperationBody(setter, "" -/*{ - Object oldValue = getField(<%=extensionVariableName%>, <%=fieldVariableName%>); - getWikitty().setField(<%=extensionVariableName%>, <%=fieldVariableName%>, <%=attribute.getName()%>); - getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, oldValue, <%=attribute.getName()%>); -}*/); - - // adding getter and setter to Helper with bodies - getter = addOperation(helper, getterName, attributeTypeSimpleName, ObjectModelModifier.STATIC); - addParameter(getter, WIKITTY_CLASS_FQN, "wikitty"); - setOperationBody(getter, "" -/*{ - <%=resultType%> result = wikitty.<%=getFieldMethodName%>(<%=extensionVariableName%>, <%=fieldVariableName%>); - return result; -}*/); - - setter = addOperation(helper, setterName, "void", ObjectModelModifier.STATIC); - addParameter(setter, WIKITTY_CLASS_FQN, "wikitty"); - addParameter(setter, attributeTypeSimpleName, attribute.getName()); - setOperationBody(setter, "" -/*{ - wikitty.setField(<%=extensionVariableName%>, <%=clazz.getName()%>.<%=fieldVariableName%>, <%=attribute.getName()%>); -}*/); - } - } +// will be moved soon +// protected void processAttribute(ObjectModelAttribute attribute) { +// // two variables needed below +// String extensionVariableName = WikittyGeneratorUtil.classToExtensionVariableName(clazz); +// String fieldVariableName = WikittyGeneratorUtil.attributeToFielVariableName(attribute); +// +// +// +// // let's find a name for the getter +// String getterName = getMethodName("get", contract, attribute, attribute.getTagValue("getter")); +// +// // let's find a name for the setter +// String setterName = getMethodName("set", contract, attribute, attribute.getTagValue("setter")); +// +// // attribute type simple name as it should be in signature +// String attributeTypeSimpleName = WikittyGeneratorUtil.FQNtoSimpleName(attribute.getType()); +// if ("boolean".equals(attributeTypeSimpleName)) { +// attributeTypeSimpleName = "Boolean"; +// } else if ("int".equals(attributeTypeSimpleName)) { +// attributeTypeSimpleName = "Integer"; +// } +// +// if (attribute.getMaxMultiplicity() > 1 || attribute.getMaxMultiplicity() == -1) { +// // attributed is a collection, we will generate operations get, add, remove and clear +// String attributeTypeSimpleNameInSet = "Set<" + attributeTypeSimpleName + ">"; +// +// // now, for this attribute, we will generate add, remove and clear methods +// +// // adding operations to contract +// ObjectModelOperation getter = addOperation(contract, getterName, attributeTypeSimpleNameInSet); +// +// String addName = getMethodName("add", contract, attribute, attribute.getTagValue("adder")); +// ObjectModelOperation adder = addOperation(contract, addName, "void"); +// addParameter(adder, "String", "element"); +// +// String removeName = getMethodName("remove", contract, attribute, attribute.getTagValue("remover")); +// ObjectModelOperation remover = addOperation(contract, removeName, "void"); +// addParameter(remover, "String", "element"); +// +// String clearName = getMethodName("clear", contract, attribute, attribute.getTagValue("clear")); +// ObjectModelOperation clear = addOperation(contract, clearName, "void"); +// +// // adding operations to abstract with bodies +// getter = cloneOperationSignature(getter, abstractClass, true, ObjectModelModifier.PUBLIC); +// String getterBody = "" +///*{ +// <%= attributeTypeSimpleNameInSet %> result = getWikitty().getFieldAsSet(<%= extensionVariableName %>, <%= fieldVariableName %>, <%= attributeTypeSimpleName %>.class); +// return result; +//}*/; +// setOperationBody(getter, getterBody); +// +// adder = cloneOperationSignature(adder, abstractClass, true, ObjectModelModifier.PUBLIC); +// String adderBody = "" +///*{ +// getWikitty().addToField(<%=extensionVariableName%>, <%=fieldVariableName%>, element); +// getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%= getter.getName() %>()); +//}*/; +// setOperationBody(adder, adderBody); +// +// remover = cloneOperationSignature(remover, abstractClass, true, ObjectModelModifier.PUBLIC); +// String removerBody = "" +///*{ +// getWikitty().removeFromField(<%=extensionVariableName%>, <%=fieldVariableName%>, element); +// getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%=getter.getName()%>()); +//}*/; +// setOperationBody(remover, removerBody); +// +// clear = cloneOperationSignature(clear, abstractClass, true, ObjectModelModifier.PUBLIC); +// String clearBody = "" +///*{ +// getWikitty().clearField(<%=extensionVariableName%>, <%=fieldVariableName%>); +// getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%=getter.getName()%>()); +//}*/; +// setOperationBody(clear, clearBody); +// +// // adding operations to Helper with bodies +// getter = addOperation(helper, getterName, attributeTypeSimpleNameInSet, ObjectModelModifier.STATIC); +// addParameter(getter, WIKITTY_CLASS_FQN, "wikitty"); +// setOperationBody(getter, "" +///*{ +// <%=attributeTypeSimpleNameInSet%> result = wikitty.getFieldAsSet(<%=extensionVariableName%>, <%=fieldVariableName%>, <%=attributeTypeSimpleName%>.class); +// return result; +//}*/); +// +// adder = addOperation(helper, addName, "void", ObjectModelModifier.STATIC); +// addParameter(adder, WIKITTY_CLASS_FQN, "wikitty"); +// addParameter(adder, attributeTypeSimpleName, "element"); +// setOperationBody(adder, "" +///*{ +// wikitty.addToField(<%=extensionVariableName%>, <%=clazz.getName()%>.<%=fieldVariableName%>, element); +//}*/ +//); +// +// remover = addOperation(helper, removeName, "void", ObjectModelModifier.STATIC); +// addParameter(remover, WIKITTY_CLASS_FQN, "wikitty"); +// addParameter(remover, attributeTypeSimpleName, "element"); +// setOperationBody(remover, "" +///*{ +// wikitty.removeFromField(<%=extensionVariableName%>, <%=clazz.getName()%>.<%=fieldVariableName%>, element); +//}*/); +// +// clear = addOperation(helper, clearName, "void", ObjectModelModifier.STATIC); +// addParameter(clear, WIKITTY_CLASS_FQN, "wikitty"); +// setOperationBody(clear, "" +///*{ +// wikitty.clearField(<%=extensionVariableName%>, <%=clazz.getName()%>.<%=fieldVariableName%>); +//}*/); +// +// } else { +// // attribute is not a collection, we generate a getter and a setter +// String getFieldMethodName = WikittyGeneratorUtil.generateGetFieldAsCall(attribute.getType()); +// String resultType = WikittyGeneratorUtil.generateResultType(attribute.getType()); +// attributeTypeSimpleName = resultType; +// +// // adding getter and setter to contract +// ObjectModelOperation getter = addOperation(contract, getterName, attributeTypeSimpleName); +// ObjectModelOperation setter = addOperation(contract, setterName, "void"); +// addParameter(setter, attributeTypeSimpleName, attribute.getName()); +// +// // adding getter and setter to abstract with bodies +// getter = cloneOperationSignature(getter, abstractClass, true, ObjectModelModifier.PUBLIC); +// setOperationBody(getter, "" +///*{ +// <%=resultType%> result = getWikitty().<%=getFieldMethodName%>(<%=extensionVariableName%>, <%=fieldVariableName%>); +// return result; +//}*/); +// +// setter = cloneOperationSignature(setter, abstractClass, true, ObjectModelModifier.PUBLIC); +// setOperationBody(setter, "" +///*{ +// Object oldValue = getField(<%=extensionVariableName%>, <%=fieldVariableName%>); +// getWikitty().setField(<%=extensionVariableName%>, <%=fieldVariableName%>, <%=attribute.getName()%>); +// getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, oldValue, <%=attribute.getName()%>); +//}*/); +// +// // adding getter and setter to Helper with bodies +// getter = addOperation(helper, getterName, attributeTypeSimpleName, ObjectModelModifier.STATIC); +// addParameter(getter, WIKITTY_CLASS_FQN, "wikitty"); +// setOperationBody(getter, "" +///*{ +// <%=resultType%> result = wikitty.<%=getFieldMethodName%>(<%=extensionVariableName%>, <%=fieldVariableName%>); +// return result; +//}*/); +// +// setter = addOperation(helper, setterName, "void", ObjectModelModifier.STATIC); +// addParameter(setter, WIKITTY_CLASS_FQN, "wikitty"); +// addParameter(setter, attributeTypeSimpleName, attribute.getName()); +// setOperationBody(setter, "" +///*{ +// wikitty.setField(<%=extensionVariableName%>, <%=clazz.getName()%>.<%=fieldVariableName%>, <%=attribute.getName()%>); +//}*/); +// } +// } - /** given "my.java.package.MyClass" or "MyClass" return "MyClass" */ - protected static String FQNtoSimpleName(String fqn) { - int lastDotIndex = fqn.lastIndexOf("."); - String simpleName = fqn; - if (lastDotIndex != -1) { - simpleName = fqn.substring(lastDotIndex + 1); - } - return simpleName; - } - - /** - * wikitty interface provide getFieldAsString, getFieldAsDate etc. methods - * this method returns the good name of the method to call depending the - * type given as parameter - * @param typeName a name of a business entity or "String", "Integer" etc. - * @return the name of a method "getFieldAsInt" for example - */ - protected static String generateGetFieldAsCall(String typeName) { - String asWhat = FQNtoSimpleName(typeName); - if ("boolean".equals(asWhat)) { - asWhat = "Boolean"; - } else if ("int".equals(asWhat) || "Integer".equals(asWhat)) { - asWhat = "Int"; - } else if ("Date".equals(asWhat)) { - // asWhat = "Date"; - } else { - asWhat = "String"; - } - return "getFieldAs" + asWhat; - } - - protected static String generateResultType(String typeName) { - String asWhat = FQNtoSimpleName(typeName); - if ("boolean".equals(asWhat)) { - // asWhat = "boolean"; - } else if ("int".equals(asWhat) || "Integer".equals(asWhat)) { - // asWhat = "Int"; - } else if ("Date".equals(asWhat)) { - // asWhat = "Date"; - } else { - asWhat = "String"; - } - return asWhat; - } - /** getMethodName("add", contract, attribute, "myNameForThisAdder") - * will return "myNameForThisAdder" if not already defined in contract + * will return "myNameForThisAdder" if not already defined in contract ; * if already defined, will try add<attributeName>. If it already exists * will return add<attributeName>From<ExtensionName> */ protected String getMethodName(String operatorName, @@ -509,15 +238,15 @@ String methodName = claimedValue; if (methodName != null) { if (! classifier.getOperations(methodName).isEmpty()) { - log.warn(methodName + " operation already exists in " + clazz.getQualifiedName() + " ignoring tagValue"); + log.warn(methodName + " operation already exists in " + attribute.getDeclaringElement().getName() + " ignoring tagValue"); methodName = null; - } + } } - + if (methodName == null) { methodName = operatorName + StringUtils.capitalize(attribute.getName()); if (! classifier.getOperations(methodName).isEmpty()) { - methodName += "From" + clazz.getName(); + methodName += "From" + attribute.getDeclaringElement().getName(); } } return methodName;