[Eugene-commits] r1266 - in trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader: . yaml

31 May 2013

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;
+    }
 }

    

[Eugene-commits] r1266 - in trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader: . yaml

agiraudet＠users.nuiton.org