r1266 - in trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader: . yaml
Author: agiraudet Date: 2013-05-31 17:50:13 +0200 (Fri, 31 May 2013) New Revision: 1266 Url: http://nuiton.org/projects/eugene/repository/revisions/1266 Log: impl?\195?\169mentation d'une nouvelle architecture pour g?\195?\169n?\195?\169rer l'ObjectModel ?\195?\160 partir d'un fichier YAML (plus modulaire) ajout du YamlObject: objet de transition entre le fichier YAML et l'ObjectModel Added: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/KeyWords.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxeUserFriendly.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/YamlObjectModelReader.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/YamlObjectModelReader.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/YamlObjectModelReader.java 2013-05-29 10:08:59 UTC (rev 1265) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/YamlObjectModelReader.java 2013-05-31 15:50:13 UTC (rev 1266) @@ -29,6 +29,7 @@ import org.apache.commons.logging.LogFactory; import org.nuiton.eugene.ModelHelper; import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.reader.yaml.TestLoadYamlFile; import org.nuiton.eugene.models.object.reader.yaml.YamlToObjectModel; import org.yaml.snakeyaml.error.YAMLException; @@ -45,7 +46,8 @@ public class YamlObjectModelReader extends AbstractObjectModelReader { private static final Log log = LogFactory.getLog(YamlObjectModelReader.class); - protected YamlToObjectModel yamlToObjectModel; + //protected YamlToObjectModel yamlToObjectModel; + protected TestLoadYamlFile test; @Override public String getInputType() { @@ -55,13 +57,15 @@ @Override protected void beforeReadFile(File... files) { super.beforeReadFile(files); - yamlToObjectModel = new YamlToObjectModel(); + //yamlToObjectModel = new YamlToObjectModel(); + test = new TestLoadYamlFile(); } @Override protected void readFileToModel(File file, ObjectModel model) throws IOException { try { - yamlToObjectModel.loadFile(file,model); + //yamlToObjectModel.loadFile(file,model); + test.LoadYamlFile(file,model); } catch (YAMLException e) { throw new IOException("Unable to parse ObjectModel input file : " + file, e); } Added: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/KeyWords.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/KeyWords.java (rev 0) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/KeyWords.java 2013-05-31 15:50:13 UTC (rev 1266) @@ -0,0 +1,51 @@ +package org.nuiton.eugene.models.object.reader.yaml; + +/** + * User: agiraudet + * Date: 30/05/13 + * Time: 10:10 + */ +public class KeyWords { + public static final String ABSTRACT = "abstract"; + public static final String ASSOCIATION_CLASS = "associationclass"; + public static final String ASSOCIATION_CLASS_NAME = "associationclassname"; + public static final String ASSOCIATION_TYPE = "associationtype"; + public static final String ATTRIBUTE = "attribute"; + public static final String BODY_CODE = "bodeycode"; + public static final String CLASS = "class"; + public static final String COMMENTS = "comments"; + public static final String DEFAULT_VALUE = "defaultvalue"; + public static final String DOCUMENTATION = "documentation"; + public static final String ENUMERATION = "enumeration"; + public static final String EXTERN = "extern"; + public static final String FINAL = "final"; + public static final String IMPORTS = "imports"; + public static final String INNER = "inner"; + public static final String INTERFACE = "interface"; + public static final String LITERAL = "literal"; + public static final String MAX_MULTIPLICITY = "maxmultiplicity"; + public static final String MIN_MULTIPLICITY = "minmultiplicity"; + public static final String NAME = "name"; + public static final String NAVIGABLE = "navigable"; + public static final String OPERATION = "operation"; + public static final String ORDERED = "ordered"; + public static final String ORDERING = "ordering"; + public static final String PACKAGE = "package"; + public static final String PARAMETER = "parameter"; + public static final String PARTICIPANT = "participant"; + public static final String RETURN_PARAMETER = "returnparameter"; + public static final String REVERSE_ATTRIBUTE_NAME = "reverseattributename"; + public static final String REVERSE_MAX_MULTIPLICITY = "reversemaxmultiplicity"; + public static final String STATIC = "static"; + public static final String STEREOTYPES = "stereotypes"; + public static final String SUPER_CLASSES = "superclasses"; + public static final String SUPER_INTERFACES = "superinterfaces"; + public static final String SYNTAXE = "syntaxe"; + public static final String TAG_VALUES = "tagvalues"; + public static final String TRANSIENT = "transient"; + public static final String TYPE = "type"; + public static final String UNIQUE = "unique"; + public static final String VERSION = "version"; + public static final String VISIBILITY = "visibility"; + public static final String ELEMENT = "element"; +} Added: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java (rev 0) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java 2013-05-31 15:50:13 UTC (rev 1266) @@ -0,0 +1,52 @@ +package org.nuiton.eugene.models.object.reader.yaml; + +import org.nuiton.eugene.models.object.ObjectModel; + +import java.util.List; +import java.util.Map; + +/** + * User: agiraudet + * Date: 30/05/13 + * Time: 11:23 + */ +//TODO: interface Syntaxe ou classe abstraite (appel l'operation suivante : charger l'ObjectModel) +//key.toLowerCase() ? +public class SyntaxePureYaml { + + public static void loadModelYaml(Object modelYAML, YamlObject modelYAMLO) + { + loadYamlObject(modelYAML, modelYAMLO, "model"); + } + + public static void loadYamlObject(Object objectYaml, YamlObject modelYaml, String previous) + { + if(objectYaml instanceof List) + { + for(Object tmp1 : (List) objectYaml) + { + loadYamlObject(tmp1, modelYaml, previous); + } + } + else if(objectYaml instanceof Map) + { + for(Object tmp1 : ((Map) objectYaml).entrySet()) + { + if(((Map.Entry) tmp1).getValue() instanceof List || ((Map.Entry) tmp1).getValue() instanceof Map) + { + YamlObject tmp2 = new YamlObject(); + loadYamlObject(((Map.Entry) tmp1).getValue(),tmp2,String.valueOf(((Map.Entry) tmp1).getKey()).toLowerCase()); + modelYaml.addYamlObjectToMap(String.valueOf(((Map.Entry) tmp1).getKey()).toLowerCase(),tmp2); + } + else + { + modelYaml.addStringToMap(String.valueOf(((Map.Entry) tmp1).getKey()).toLowerCase(),String.valueOf(((Map.Entry) tmp1).getValue())); + } + } + } + /*else + { + modelYaml.addStringToMap(previous,String.valueOf(objectYaml)); + }*/ + } +} Added: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxeUserFriendly.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxeUserFriendly.java (rev 0) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxeUserFriendly.java 2013-05-31 15:50:13 UTC (rev 1266) @@ -0,0 +1,10 @@ +package org.nuiton.eugene.models.object.reader.yaml; + +/** + * User: agiraudet + * Date: 30/05/13 + * Time: 11:24 + */ +//TODO: interface Syntaxe pour futures syntaxes +public class SyntaxeUserFriendly { +} Added: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java (rev 0) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java 2013-05-31 15:50:13 UTC (rev 1266) @@ -0,0 +1,606 @@ +package org.nuiton.eugene.models.object.reader.yaml; + +import org.nuiton.eugene.models.object.*; +import org.nuiton.eugene.models.object.xml.*; + +import java.io.FileWriter; +import java.io.IOException; +import java.util.*; + +/** + * User: agiraudet + * Date: 30/05/13 + * Time: 11:58 + */ +public class TestLoadObjectModel extends KeyWords { + List<String> imports; + String packageL;//package local + + private boolean _loginit = true; + private void log(String str) { + try { + FileWriter log; + String path = "/tmp/log.yamlobject.txt"; + + if (_loginit) { + log = new FileWriter(path, false); + log.close(); + _loginit = false; + } + log = new FileWriter(path, true); + log.write("[LOG] " + str + "\n"); + log.close(); + } catch (IOException e) {;} + } + + //precondition: labels et imports resolus + //TODO: valeurs par defaut + public TestLoadObjectModel(/*YamlObject modelYAMLO, ObjectModelImpl modelOM*/) + { + ;//loadModel(modelYAMLO,modelOM); + } + + public void loadModel(YamlObject modelYAMLO, ObjectModelImpl modelOM) { + + //log + log(modelYAMLO.toString()); + log(" MODEL"); + //log + + String packageYAMLO = modelYAMLO.getFirstMapStringListString(PACKAGE); + if(packageYAMLO == null) + { + packageL = ""; + } + else + { + packageL = packageYAMLO; + } + log("package="+packageL); + + String nameYAMLO = modelYAMLO.getFirstMapStringListString(NAME); + if(nameYAMLO == null) + { + ;//valeur par defaut + } + else + { + modelOM.setName(nameYAMLO); + log("name="+modelOM.getName()); + } + + String versionYAMLO = modelYAMLO.getFirstMapStringListString(VERSION); + if(versionYAMLO == null) + { + ;//valeur par defaut + } + else + { + modelOM.setVersion(versionYAMLO); + log("version="+modelOM.getVersion()); + } + + //tagvalues + YamlObject tagValues = modelYAMLO.getFirstMapStringListYamlObject(TAG_VALUES); + if(tagValues != null) + { + for(Map.Entry<String,List<String>> tagValue :tagValues.getMapStringListString().entrySet()) + { + if(!tagValue.getValue().isEmpty())//taille strictement = 1 + { + modelOM.addTagValue(tagValue.getKey(),tagValue.getValue().get(0)); + } + } + log("tagValues="+modelOM.getTagValues()); + } + + //classes + for(YamlObject classYAMLO : modelYAMLO.getMapStringListYamlObject(CLASS)) + { + log(" CLASS"); + ObjectModelClassImpl classOM = new ObjectModelClassImpl(); + loadClass(classYAMLO,classOM); + modelOM.addClass(classOM); + } + //interfaces + for(YamlObject interfaceYAMLO : modelYAMLO.getMapStringListYamlObject(INTERFACE)) + { + log(" INTERFACE"); + ObjectModelInterfaceImpl interfaceOM = new ObjectModelInterfaceImpl(); + loadInterface(interfaceYAMLO,interfaceOM); + modelOM.addInterface(interfaceOM); + } + //classes d'association + for(YamlObject associationClassYAMLO : modelYAMLO.getMapStringListYamlObject(ASSOCIATION_CLASS)) + { + log(" ASSOCIATION_CLASS"); + ObjectModelAssociationClassImpl associationClassOM = new ObjectModelAssociationClassImpl(); + loadAssociationClass(associationClassYAMLO,associationClassOM); + modelOM.addAssociationClass(associationClassOM); + } + //enumerations + for(YamlObject enumerationYAMLO : modelYAMLO.getMapStringListYamlObject(ENUMERATION)) + { + log(" ENUMERATION"); + ObjectModelEnumerationImpl enumerationOM = new ObjectModelEnumerationImpl(); + loadEnumeration(enumerationYAMLO,enumerationOM); + modelOM.addEnumeration(enumerationOM); + } + } + + public void loadElement(YamlObject elementYAMLO, ObjectModelElementImpl elementOM) + { + String nameYAMLO = elementYAMLO.getFirstMapStringListString(NAME); + if(nameYAMLO == null) + { + ;//valeur par defaut + } + else + { + elementOM.setName(nameYAMLO); + log("name="+elementOM.getName()); + } + + String staticYAMLO = elementYAMLO.getFirstMapStringListString(STATIC); + if(staticYAMLO == null) + { + ;//valeur par defaut + } + else + { + elementOM.setStatic(Boolean.valueOf(staticYAMLO)); + log("static="+elementOM.isStatic()); + } + + String documentationYAMLO = elementYAMLO.getFirstMapStringListString(DOCUMENTATION); + if(documentationYAMLO == null) + { + ;//valeur par defaut + } + else + { + elementOM.setDocumentation(documentationYAMLO); + log("documentation="+elementOM.getDocumentation()); + } + + YamlObject tagValues = elementYAMLO.getFirstMapStringListYamlObject(TAG_VALUES); + if(tagValues != null) + { + for(Map.Entry<String,List<String>> tagValue :tagValues.getMapStringListString().entrySet()) + { + if(!tagValue.getValue().isEmpty())//taille strictement = 1 + { + elementOM.addTagValue(tagValue.getKey(),tagValue.getValue().get(0)); + } + } + log("tagValues="+elementOM.getTagValues()); + } + + List<String> comments = elementYAMLO.getMapStringListString(COMMENTS); + for(String comment : comments) + { + elementOM.addComment(comment); + log("comments="+elementOM.getComments()); + } + + List<String> stereotypes = elementYAMLO.getMapStringListString(STEREOTYPES); + for(String stereotype : stereotypes) + { + ObjectModelImplRef stereotypeOM = new ObjectModelImplRef(); + stereotypeOM.setName(stereotype); + elementOM.addStereotype(stereotypeOM); + log("stereotype="+elementOM.getStereotypes()); + } + } + + public void loadClassifier(YamlObject classifierYAMLO, ObjectModelClassifierImpl classifierOM) + { + loadElement(classifierYAMLO, classifierOM); + + String packageYAMLO = classifierYAMLO.getFirstMapStringListString(PACKAGE); + if(packageYAMLO == null) + { + //TODO: tester packageL == null + classifierOM.setPackage(packageL); + } + else + { + classifierOM.setPackage(packageYAMLO); + } + log("package="+classifierOM.getPackageName()); + + + String externYAMLO = classifierYAMLO.getFirstMapStringListString(EXTERN); + if(externYAMLO == null) + { + ;//valeur par defaut + } + else + { + classifierOM.setExtern(Boolean.valueOf(externYAMLO)); + log("extern="+classifierOM.isExtern()); + + } + + String innerYAMLO = classifierYAMLO.getFirstMapStringListString(INNER); + if(innerYAMLO == null) + { + ;//valeur par defaut + } + else + { + classifierOM.setInner(Boolean.valueOf(innerYAMLO)); + log("inner="+classifierOM.isInner()); + } + + String typeYAMLO = classifierYAMLO.getFirstMapStringListString(TYPE); + if(typeYAMLO == null) + { + ;//valeur par defaut + } + else + { + classifierOM.setType(typeYAMLO); + log("type="+typeYAMLO);//getType ? + } + + for(YamlObject attributeYAMLO : classifierYAMLO.getMapStringListYamlObject(ATTRIBUTE)) + { + log(" ATTRIBUTE"); + ObjectModelAttributeImpl attributeOM = new ObjectModelAttributeImpl(); + loadAttribute(attributeYAMLO,attributeOM); + classifierOM.addAttribute(attributeOM); + } + + for(YamlObject operationYAMLO : classifierYAMLO.getMapStringListYamlObject(OPERATION)) + { + log(" OPERATION"); + ObjectModelOperationImpl operationOM = new ObjectModelOperationImpl(); + loadOperation(operationYAMLO,operationOM); + classifierOM.addOperation(operationOM); + } + + List<String> superInterfacesYAMLO = classifierYAMLO.getMapStringListString(SUPER_INTERFACES); + for(String superInterfaceYAMLO : superInterfacesYAMLO) + { + log(" SUPER_INTERFACE"); + ObjectModelImplRef superInterfaceOM = new ObjectModelImplRef(); + superInterfaceOM.setName(superInterfaceYAMLO); + classifierOM.addInterface(superInterfaceOM); + } + } + + public void loadClass(YamlObject classYAMLO, ObjectModelClassImpl classOM) + { + loadClassifier(classYAMLO, classOM); + + String abstractYAMLO = classYAMLO.getFirstMapStringListString(ABSTRACT); + if(abstractYAMLO == null) + { + ;//valeur par defaut + } + else + { + classOM.setAbstract(Boolean.valueOf(abstractYAMLO)); + log("abstract="+classOM.isAbstract()); + } + + List<String> superClassesYAMLO = classYAMLO.getMapStringListString(SUPER_CLASSES); + for(String superClassYAMLO : superClassesYAMLO) + { + ObjectModelImplRef superClassOM = new ObjectModelImplRef(); + superClassOM.setName(superClassYAMLO); + classOM.addInterface(superClassOM); + log("superClasses="+classOM.getSuperclasses()); + } + } + + public void loadInterface(YamlObject interfaceYAMLO, ObjectModelInterfaceImpl interfaceOM) + { + loadClassifier(interfaceYAMLO,interfaceOM); + } + + public void loadAssociationClass(YamlObject associationClassYAML, ObjectModelAssociationClassImpl associationClassOM) + { + loadClass(associationClassYAML, associationClassOM); + + //TODO: remplacer name par type et attribute par name ? + for(YamlObject participantYAMLO : associationClassYAML.getMapStringListYamlObject(PARTICIPANT)) + { + log(" PARTICIPANT"); + ObjectModeImplAssociationClassParticipant participantOM = new ObjectModeImplAssociationClassParticipant(); + participantOM.setAssociationClass(associationClassOM); + + String nameYAMLO = participantYAMLO.getFirstMapStringListString(NAME); + if(nameYAMLO == null) + { + ;//valeur par defaut + } + else + { + participantOM.setName(nameYAMLO); + log("name="+participantOM.getName()); + } + + String attributeYAMLO = participantYAMLO.getFirstMapStringListString(ATTRIBUTE); + if(attributeYAMLO == null) + { + ;//valeur par defaut + } + else + { + participantOM.setAttribute(attributeYAMLO); + log("attribute="+participantOM.getAttributeName()); + } + + associationClassOM.addParticipant(participantOM); + } + } + + public void loadEnumeration(YamlObject enumerationYAMLO, ObjectModelEnumerationImpl enumerationOM) + { + loadElement(enumerationYAMLO, enumerationOM); + + //TODO: remplacer LITERAL par LITERALS (List) + List<String> literalsYAMLO = enumerationYAMLO.getMapStringListString(LITERAL); + for(String literalYAMLO : literalsYAMLO) + { + ObjectModelImplRef literalOM = new ObjectModelImplRef(); + literalOM.setName(literalYAMLO); + enumerationOM.addLiteral(literalOM); + log("literals="+enumerationOM.getLiterals()); + } + + String packageYAMLO = enumerationYAMLO.getFirstMapStringListString(PACKAGE); + if(packageYAMLO == null) + { + enumerationOM.setPackage(packageL); + } + else + { + enumerationOM.setPackage(packageYAMLO); + } + log("package="+enumerationOM.getPackageName()); + } + + public void loadParameter(YamlObject parameterYAMLO, ObjectModelParameterImpl parameterOM) + { + loadElement(parameterYAMLO,parameterOM); + + String orderingYAMLO = parameterYAMLO.getFirstMapStringListString(ORDERING); + if(orderingYAMLO == null) + { + ;//valeur par defaut + } + else + { + parameterOM.setOrdering(orderingYAMLO); + log("ordering="+orderingYAMLO);//getOrdering ? + } + + String typeYAMLO = parameterYAMLO.getFirstMapStringListString(TYPE); + if(typeYAMLO == null) + { + ;//valeur par defaut + } + else + { + parameterOM.setType(typeYAMLO); + log("type="+parameterOM.getType()); + } + + String defaultValueYAMLO = parameterYAMLO.getFirstMapStringListString(DEFAULT_VALUE); + if(defaultValueYAMLO == null) + { + ;//default + } + else + { + parameterOM.setDefaultValue(defaultValueYAMLO); + log("defaultValue="+parameterOM.getDefaultValue()); + } + + String minMultiplicityYAMLO = parameterYAMLO.getFirstMapStringListString(MIN_MULTIPLICITY); + if(minMultiplicityYAMLO == null) + { + ;//valeur par defaut + } + else + { + parameterOM.setMinMultiplicity(Integer.valueOf(minMultiplicityYAMLO)); + log("minMultiplicity="+parameterOM.getMinMultiplicity()); + } + + String maxMultiplicityYAMLO = parameterYAMLO.getFirstMapStringListString(MAX_MULTIPLICITY); + if(maxMultiplicityYAMLO == null) + { + ;//valeur par defaut + } + else + { + parameterOM.setMaxMultiplicity(Integer.valueOf(maxMultiplicityYAMLO)); + log("maxMultiplicity="+parameterOM.getMaxMultiplicity()); + + } + + String orderedYAMLO = parameterYAMLO.getFirstMapStringListString(ORDERED); + if(orderedYAMLO == null) + { + ;//valeur par defaut + } + else + { + parameterOM.setOrdered(Boolean.valueOf(orderedYAMLO)); + log("ordered="+parameterOM.isOrdered()); + } + + String uniqueYAMLO = parameterYAMLO.getFirstMapStringListString(UNIQUE); + if(uniqueYAMLO == null) + { + ;//valeur par defaut + } + else + { + parameterOM.setUnique(Boolean.valueOf(uniqueYAMLO)); + log("unique="+parameterOM.isUnique()); + } + } + + public void loadAttribute(YamlObject attributeYAMLO, ObjectModelAttributeImpl attributeOM) + { + loadParameter(attributeYAMLO,attributeOM); + + String navigableYAMLO = attributeYAMLO.getFirstMapStringListString(NAVIGABLE); + if(navigableYAMLO == null) + { + ;//valeur par defaut + } + else + { + attributeOM.setNavigable(Boolean.valueOf(navigableYAMLO)); + log("navigable="+attributeOM.isNavigable()); + } + + String associationTypeYAMLO = attributeYAMLO.getFirstMapStringListString(ASSOCIATION_TYPE); + if(associationTypeYAMLO == null) + { + ;//valeur par defaut + } + else + { + attributeOM.setAssociationType(associationTypeYAMLO); + log("associationType="+associationTypeYAMLO);//getAssociationType ? + } + + String finalYAMLO = attributeYAMLO.getFirstMapStringListString(FINAL); + if(finalYAMLO == null) + { + ;//valeur par defaut + } + else + { + attributeOM.setFinal(Boolean.valueOf(finalYAMLO)); + log("final="+attributeOM.isFinal()); + } + + String staticYAMLO = attributeYAMLO.getFirstMapStringListString(STATIC); + if(staticYAMLO == null) + { + ;//valeur par defaut + } + else + { + attributeOM.setStatic(Boolean.valueOf(staticYAMLO)); + log("static="+attributeOM.isStatic()); + } + + String associationClassNameYAMLO = attributeYAMLO.getFirstMapStringListString(ASSOCIATION_CLASS_NAME); + if(associationClassNameYAMLO == null) + { + ;//valeur par defaut + } + else + { + attributeOM.setAssociationClassName(associationClassNameYAMLO); + log("associationClassName="+associationClassNameYAMLO); + } + + String reverseAttributeNameYAMLO = attributeYAMLO.getFirstMapStringListString(REVERSE_ATTRIBUTE_NAME); + if(reverseAttributeNameYAMLO == null) + { + ;//valeur par defaut + } + else + { + attributeOM.setReverseAttributeName(reverseAttributeNameYAMLO); + log("reverseAttributeName="+attributeOM.getReverseAttributeName()); + } + + String reverseMaxMultiplicityYAMLO = attributeYAMLO.getFirstMapStringListString(REVERSE_MAX_MULTIPLICITY); + if(reverseMaxMultiplicityYAMLO == null) + { + ;//valeur par defaut + } + else + { + attributeOM.setReverseMaxMultiplicity(Integer.valueOf(reverseMaxMultiplicityYAMLO)); + log("reverseMaxMultiplicity="+attributeOM.getReverseMaxMultiplicity()); + } + + String transientYAMLO = attributeYAMLO.getFirstMapStringListString(TRANSIENT); + if(transientYAMLO == null) + { + ;//valeur par defaut + } + else + { + attributeOM.setTransient(Boolean.valueOf(transientYAMLO)); + log("transient="+attributeOM.isTransient()); + } + + String visibilityYAMLO = attributeYAMLO.getFirstMapStringListString(VISIBILITY); + if(visibilityYAMLO == null) + { + ;//valeur par defaut + } + else + { + attributeOM.setVisibility(visibilityYAMLO); + log("visibility="+attributeOM.getVisibility()); + } + } + + public void loadOperation(YamlObject operationYAMLO, ObjectModelOperationImpl operationOM) + { + loadElement(operationYAMLO,operationOM); + + String abstractYAMLO = operationYAMLO.getFirstMapStringListString(ABSTRACT); + if(abstractYAMLO == null) + { + ;//valeur par defaut + } + else + { + operationOM.setAbstract(Boolean.valueOf(abstractYAMLO)); + log("abstract="+operationOM.isAbstract()); + } + + String visibilityYAMLO = operationYAMLO.getFirstMapStringListString(VISIBILITY); + if(visibilityYAMLO == null) + { + ;//valeur par defaut + } + else + { + operationOM.setVisibility(visibilityYAMLO); + log("visibility="+operationOM.getVisibility()); + } + + for(YamlObject returnParameterYAMLO : operationYAMLO.getMapStringListYamlObject(RETURN_PARAMETER)) + { + log(" RETURN_PARAMETER"); + ObjectModelParameterImpl returnParameterOM = new ObjectModelAttributeImpl(); + loadParameter(returnParameterYAMLO,returnParameterOM); + operationOM.setReturnParameter(returnParameterOM); + } + + for(YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(PARAMETER)) + { + log(" PARAMETER"); + ObjectModelParameterImpl parameterOM = new ObjectModelAttributeImpl(); + loadParameter(parameterYAMLO,parameterOM); + operationOM.addParameter(parameterOM); + } + + String bodyCodeYAMLO = operationYAMLO.getFirstMapStringListString(BODY_CODE); + if(bodyCodeYAMLO == null) + { + ;//valeur par defaut + } + else + { + operationOM.setBodyCode(bodyCodeYAMLO); + log("bodyCode="+operationOM.getBodyCode()); + } + } +} Added: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java (rev 0) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java 2013-05-31 15:50:13 UTC (rev 1266) @@ -0,0 +1,70 @@ +package org.nuiton.eugene.models.object.reader.yaml; + +import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.xml.ObjectModelImpl; +import org.yaml.snakeyaml.Yaml; + +import java.io.*; +import java.util.*; + +/** + * User: agiraudet + * Date: 28/05/13 + * Time: 16:35 + * + * Rôle: parser le fichier YAML et le transformer en YAMLobject + * + * parser si besoin et charger le YAMLobject + * parse en fonction de la version + */ +public class TestLoadYamlFile extends KeyWords { + Yaml yaml; + ObjectModelImpl modelOM; + YamlObject modelYAMLO; + Object modelYAML; + String syntaxeVersion;//version de la synatxe + String defaultVersion;//version des valeurs par defaut + + public TestLoadYamlFile() + { + yaml = new Yaml(); + } + + public void LoadYamlFile(File fileYAML, ObjectModel model) throws IOException { + modelOM = (ObjectModelImpl) model; + modelYAMLO = new YamlObject(); + InputStream inputModel = new FileInputStream(fileYAML); + modelYAML = yaml.load(inputModel); + inputModel.close(); + + //chercher version et charger en conséquent + syntaxeVersion="1"; + defaultVersion="0"; + if(modelYAML instanceof List) + { + Object version = YamlUtil.collectElement((List) modelYAML, SYNTAXE); + if(version != null) + { + syntaxeVersion = YamlUtil.beforeChar(String.valueOf(version),'.'); + defaultVersion = YamlUtil.afterChar(String.valueOf(version),'.'); + } + } + if(syntaxeVersion.equals("1")) + { + SyntaxePureYaml.loadModelYaml(modelYAML, modelYAMLO); + } + else if(syntaxeVersion.equals("2")) + { + ;//syntaxe user firendly : coming soon + } + else + { + ;//syntaxe par defaut, si version syntaxe non reconnue + SyntaxePureYaml.loadModelYaml(modelYAML, modelYAMLO); + } + + TestLoadObjectModel test = new TestLoadObjectModel(); + test.loadModel(modelYAMLO,modelOM); + //TODO: charger ObjectModel avec les valeurs par defaut en fonction de la version (ajouter parametre à loadModel) + } +} Added: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java (rev 0) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java 2013-05-31 15:50:13 UTC (rev 1266) @@ -0,0 +1,222 @@ +package org.nuiton.eugene.models.object.reader.yaml; + +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +/** + * User: agiraudet + * Date: 28/05/13 + * Time: 16:41 + */ +public class YamlObject { + protected Map<String,List<String>> mapStringListString; + protected Map<String, List<YamlObject>> mapStringListYamlObject; + //TODO: améliorer nom méthodes + + public YamlObject() + { + mapStringListString = new LinkedHashMap<String, List<String>>(); + mapStringListYamlObject = new LinkedHashMap<String, List<YamlObject>>(); + } + + public void addYamlObjectToMap(String key, YamlObject value) + { + if(mapStringListYamlObject.containsKey(key)) + { + mapStringListYamlObject.get(key).add(value); + } + else + { + List<YamlObject> tmp = new LinkedList<YamlObject>(); + tmp.add(value); + mapStringListYamlObject.put(key,tmp); + } + } + + public void addStringToMap(String key, String value) + { + if(mapStringListString.containsKey(key)) + { + mapStringListString.get(key).add(value); + } + else + { + List<String> tmp = new LinkedList<String>(); + tmp.add(value); + mapStringListString.put(key,tmp); + } + } + + public YamlObject getFirstMapStringListYamlObject(String key) + { + if(mapStringListYamlObject.containsKey(key)) + { + if(!mapStringListYamlObject.isEmpty()) + { + return mapStringListYamlObject.get(key).get(0); + } + } + return null; } + + public String getFirstMapStringListString(String key) + { + if( mapStringListString.containsKey(key)) + { + if(! mapStringListString.isEmpty()) + { + return mapStringListString.get(key).get(0); + } + } + return null; + } + + public boolean isUniqueMapStringListYamlObject(String key) + { + return (sizeOfMapStringListYamlObject(key) == 1); + } + + public boolean isUniqueMapStringListString(String key) + { + return (sizeOfMapStringListString(key) == 1); + } + + public boolean containsKeyYamlMapStringListYamlObject(String key) + { + return mapStringListYamlObject.containsKey(key); + } + + public boolean containsKeyMapStringListString(String key) + { + return mapStringListString.containsKey(key); + } + + public List<YamlObject> getMapStringListYamlObject(String key) + { + if(mapStringListYamlObject.containsKey(key)) + { + if(!mapStringListYamlObject.isEmpty()) + { + return mapStringListYamlObject.get(key); + } + } + //return null; + return new LinkedList<YamlObject>(); + } + + public List<String> getMapStringListString(String key) + { + if(mapStringListString.containsKey(key)) + { + if(!mapStringListString.isEmpty()) + { + return mapStringListString.get(key); + } + } + //return null; + return new LinkedList<String>(); + } + + public int sizeOfMapStringListYamlObject(String key) + { + if(mapStringListYamlObject.containsKey(key)) + { + return mapStringListYamlObject.get(key).size(); + } + return 0;//-1 + } + + public int sizeOfMapStringListString(String key) + { + if(mapStringListString.containsKey(key)) + { + return mapStringListString.get(key).size(); + } + return 0;//-1 + } + + public Map<String, List<YamlObject>> getMapStringListYamlObject() + { + return mapStringListYamlObject; + } + + public Map<String, List<String>> getMapStringListString() + { + return mapStringListString; + } + + public boolean removeMapStringListString(String key, String value) + { + if(mapStringListString.containsKey(key)) + { + return mapStringListString.get(key).remove(value); + } + return false; + } + + public boolean removeMapStringString(String key) + { + if(mapStringListString.containsKey(key)) + { + mapStringListString.remove(key); + return true; + } + return false; + } + + public boolean removeMapStringListYamlObject(String key, YamlObject value) + { + if(mapStringListYamlObject.containsKey(key)) + { + return mapStringListYamlObject.get(key).remove(value); + } + return false; + } + + public boolean removeMapStringListYamlObject(String key) + { + if(mapStringListYamlObject.containsKey(key)) + { + mapStringListYamlObject.remove(key); + return true; + } + return false; + } + + @Override + public boolean equals(Object o) { + if(o instanceof YamlObject) + { + return (mapStringListYamlObject.equals(((YamlObject) o).getMapStringListYamlObject()) && mapStringListString.equals(((YamlObject) o).getMapStringListString())); + } + return false; + } + + @Override + public String toString() + { + return toString("- "); + } + + public String toString(String indentation) + { + StringBuilder res = new StringBuilder(); + + for(Map.Entry<String,List<String>> entry : mapStringListString.entrySet()) + { + for(String str : entry.getValue()) + { + res.append(indentation).append(entry.getKey()).append(": ").append(str).append("\n"); + } + } + for(Map.Entry<String,List<YamlObject>> entry : mapStringListYamlObject.entrySet()) + { + for(YamlObject yobj : entry.getValue()) + { + res.append(indentation).append(entry.getKey()).append(":\n").append(yobj.toString( " "+indentation)).append("\n"); + } + } + return res.toString(); + } +} Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java 2013-05-29 10:08:59 UTC (rev 1265) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java 2013-05-31 15:50:13 UTC (rev 1266) @@ -1,29 +1,5 @@ package org.nuiton.eugene.models.object.reader.yaml; -/* - * #%L - * EUGene :: EUGene - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2004 - 2013 CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ - import org.nuiton.eugene.models.object.*; import org.nuiton.eugene.models.object.xml.*; import org.yaml.snakeyaml.Yaml; @@ -121,6 +97,7 @@ * nouvelle implémentation : contraintes : labels, valeurs par défaut, parser des chaines (imports internes/externes) * */ + //http://demo.codelutin.com/pollen/poll/summary/23f361a09411482eb6be219ddf4ab5... public void loadFile(File file, ObjectModel model) throws IOException { //TODO: valeurs par defaut, faire interface ? ou simple map ? + mots clefs ? defaultValues = new LinkedHashMap<String, String>(); @@ -209,8 +186,8 @@ } } - //test imports objets modele - List<Object> objectsYAML = collectAllElements((List) modelYAML, CLASS); + /*//test imports objets modele + /*List<Object> objectsYAML = collectAllElements((List) modelYAML, CLASS); objectsYAML.addAll(collectAllElements((List) modelYAML, INTERFACE)); objectsYAML.addAll(collectAllElements((List) modelYAML, CLASS_ASSOCIATION)); objectsYAML.addAll(collectAllElements((List) modelYAML, ENUMERATION)); @@ -225,7 +202,7 @@ log(imports.toString()); } } - //test imports objets modele + *///test imports objets modele List classesYAML = collectAllElements((List) modelYAML, CLASS); for (Object classYAML : classesYAML) { Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java 2013-05-29 10:08:59 UTC (rev 1265) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java 2013-05-31 15:50:13 UTC (rev 1266) @@ -1,29 +1,5 @@ package org.nuiton.eugene.models.object.reader.yaml; -/* - * #%L - * EUGene :: EUGene - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2004 - 2013 CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ - import java.util.*; /** @@ -31,6 +7,9 @@ * Date: 14/05/13 * Time: 11:53 */ + +//TODO: faire classes dédiée au parser ? + public class YamlUtil { //TODO: caster proprement public static void keySetToLowerCase(Map<Object, Object> map) { @@ -81,4 +60,27 @@ StringBuilder out = new StringBuilder(beforeChar(in.reverse().toString(), target)); return out.reverse().toString(); } + + public static Object collectElement(List data, Object key) { + for (Object obj : data) { + if (obj instanceof Map) { + if (((Map) obj).containsKey(key)) { + return ((Map) obj).get(key); + } + } + } + return null; + } + + public static List<Object> collectAllElements(List data, Object key) { + List<Object> res = new LinkedList<Object>(); + for (Object obj : data) { + if (obj instanceof Map) { + if (((Map) obj).containsKey(key)) { + res.add(((Map) obj).get(key)); + } + } + } + return res; + } }
participants (1)
-
agiraudet＠users.nuiton.org