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

14 May 2013

Author: agiraudet
Date: 2013-05-14 11:45:39 +0200 (Tue, 14 May 2013)
New Revision: 1245

Url: http://nuiton.org/projects/eugene/repository/revisions/1245

Log:
modification de eugene/models/object/reader/YamlObjectModelReader.java : cr?\195?\169ation d'une seule instance du parseur YAML lors de la g?\195?\169n?\195?\169ration (contre une instance par fichier avant)
modification de eugene/models/object/reader/yaml/YamlToObjectModel.java: gestion des attributs, imports et packages

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

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-13 10:01:52 UTC (rev 1244)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/YamlObjectModelReader.java	2013-05-14 09:45:39 UTC (rev 1245)
@@ -44,8 +44,8 @@
  */
 public class YamlObjectModelReader extends AbstractObjectModelReader {
 
-    private static final Log log =
-            LogFactory.getLog(YamlObjectModelReader.class);
+    private static final Log log = LogFactory.getLog(YamlObjectModelReader.class);
+    protected YamlToObjectModel yamlToObjectModel;
 
     @Override
     public String getInputType() {
@@ -55,7 +55,8 @@
     @Override
     protected void beforeReadFile(File... files) {
         super.beforeReadFile(files);
-        //TODO ?
+        //TODO : instancier parser yaml + controler clefs des maps
+        yamlToObjectModel = new YamlToObjectModel();
     }
 
     @Override
@@ -64,8 +65,7 @@
             //TODO
             //test
             //NOTE: model deja instance
-            YamlToObjectModel tmp = new YamlToObjectModel();
-            tmp.test(file, model);
+            yamlToObjectModel.test(file, model);
             //test
         } catch (YAMLException e) {
             throw new IOException("Unable to parse ObjectModel input file : " + file, e);

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-13 10:01:52 UTC (rev 1244)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java	2013-05-14 09:45:39 UTC (rev 1245)
@@ -1,6 +1,6 @@
 package org.nuiton.eugene.models.object.reader.yaml;
 
-import org.nuiton.eugene.models.object.ObjectModel;
+import org.nuiton.eugene.models.object.*;
 import org.nuiton.eugene.models.object.xml.*;
 import org.yaml.snakeyaml.Yaml;
 
@@ -16,15 +16,26 @@
  * Note2: surcharger les méthodes ou le langage pour les prochaines syntaxes ?
  */
 public class YamlToObjectModel {
-    protected Object data;
     protected Yaml yaml;
-    protected ObjectModelImpl model;
+    protected Object modelYAML;
+    protected ObjectModelImpl modelOM;
 
+    protected String packageOM;
+    protected Map<String,String> imports;
+
     private String _log = "/tmp/log.yaml.txt";
 
     public YamlToObjectModel() {
         //TODO : mettre toutes les clefs des Maps en minuscules
         //TODO : instancier le parseur YAML (éviter une instance par fichier chargé)
+        //TODO : verifier syntaxe du code -> utiliser convention de Sun
+        //TODO : differencier attributs optionnels/obligatoires :: if null -> valeur par defaut, else -> valeur | valeurs par defaut dans fichier yaml ?
+        //TODO : charger les éléments du même niveau dans la même méthode
+        //TODO : Impl or not Impl ?
+        yaml = new Yaml();
+        modelYAML = null;
+        modelOM = null;
+
         this.startLog();
     }
 
@@ -32,7 +43,7 @@
         FileWriter log = null;
         try {
             log = new FileWriter(this._log, false);
-            log.write("[LOG] start\n");
+            log.write("[LOG] start v1.0\n");
             log.close();
         } catch (IOException e) {
             e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
@@ -50,63 +61,119 @@
         }
     }
 
-    public void test(File file, ObjectModel _model) throws IOException {
+    public void test(File file, ObjectModel model) throws IOException {
         //load file
         InputStream input = new FileInputStream(file);
-        this.yaml = new Yaml();
-        this.data = this.yaml.load(input);
+        modelYAML = this.yaml.load(input);
         input.close();
         //file loaded
-
-        this.model = (ObjectModelImpl) _model;
-
-        this.loadModel();
-
+        modelOM = (ObjectModelImpl) model;
+        loadModel();
     }
 
     //TODO : utiliser design pattern
     //TODO : utiliser genericite
     public void loadModel() {
-        if (this.data instanceof ArrayList) {
-            this.model.setName(String.valueOf(this.collectElement((List) this.data, "name")));
-            this.model.setVersion(String.valueOf(this.collectElement((List) this.data, "version")));
+        if (modelYAML instanceof List) {
+            loadImports();
+            Object nameYAML = collectElement((List) modelYAML, "name");
+            if(nameYAML != null)
+            {
+                modelOM.setName(String.valueOf(nameYAML));
+            }
+            else
+            {
+                ;//TODO : charger valeur par defaut ou lever exception ?
+            }
 
-            List _classesYAML = this.collectAllElement((List) this.data, "class");
-            for (Object _classYAML : _classesYAML) {
-                this.loadClass(_classYAML);
+            Object versionYAML = collectElement((List) modelYAML, "version");
+            if(versionYAML != null)
+            {
+                modelOM.setVersion(String.valueOf(versionYAML));
             }
+            else
+            {
+                ;//TODO : charger valeur par defaut
+            }
 
+            Object packageYAML = collectElement((List) modelYAML, "package");
+            if(packageYAML != null)
+            {
+                packageOM = String.valueOf(packageYAML);
+            }
+            else
+            {
+                ;//TODO : charger valeur par defaut
+            }
+
+            //modelOM.setName(String.valueOf(this.collectElement((List) modelYAML, "name")));
+            //modelOM.setVersion(String.valueOf(this.collectElement((List) modelYAML, "version")));
+
+            List classesYAML = this.collectAllElement((List) modelYAML, "class");
+            for (Object classYAML : classesYAML) {
+                ObjectModelClassImpl classOM = loadClass(classYAML);
+                //tester null ?
+                modelOM.addClass(classOM);
+            }
         } else {
             ;//TODO : lever exception
         }
     }
 
-    public void loadClass(Object _classYAML) {
-        if (_classYAML instanceof List) {
-            ObjectModelClassImpl _classOM = new ObjectModelClassImpl();
+    public ObjectModelClassImpl loadClass(Object classYAML) {
+        if (classYAML instanceof List) {
+            ObjectModelClassImpl classOM = new ObjectModelClassImpl();
 
-            this.loadStereotypes((List) _classYAML, _classOM);
-            this.loadTagValues((List) _classYAML, _classOM);
-            this.loadComments((List) _classYAML, _classOM);
+            this.loadStereotypes((List) classYAML, classOM);
+            this.loadTagValues((List) classYAML, classOM);
+            this.loadComments((List) classYAML, classOM);
 
-            _classOM.setName(String.valueOf(this.collectElement((List) _classYAML, "name")));
-            //Object _final = this.collectElement((List) _classYAML, "final");//final not implemented by ObjectModel
-            Object _abstract = this.collectElement((List) _classYAML, "abstract");
+            classOM.setPackage(packageOM);
+
+            Object nameYAML = collectElement((List) classYAML, "name");
+            if(nameYAML != null)
+            {
+                classOM.setName(String.valueOf(nameYAML));
+            }
+            else
+            {
+                //TODO : lever exception ?
+            }
+
+            Object abstractYAML = collectElement((List) classYAML, "abstract");
+            if(abstractYAML != null)
+            {
+                classOM.setAbstract(Boolean.valueOf(String.valueOf(abstractYAML)));//degolass
+            }
+            else
+            {
+                ;//TODO : charger la valeur par defaut
+            }
+
+            /*classOM.setName(String.valueOf(this.collectElement((List) classYAML, "name")));
+            //Object finalYAML = this.collectElement((List) classYAML, "final");//final not implemented by ObjectModel
+            Object abstractYAML = this.collectElement((List) classYAML, "abstract");
             //TODO : utiliser operateur ternaire
-            if (_abstract instanceof Boolean) {
-                _classOM.setAbstract((Boolean) _abstract);
+            if (abstractYAML instanceof Boolean) {
+                classOM.setAbstract((Boolean) abstractYAML);
             } else//sale
             {
-                _classOM.setAbstract(Boolean.valueOf(String.valueOf(_abstract)));
-            }
+                classOM.setAbstract(Boolean.valueOf(String.valueOf(abstractYAML)));
+            }*/
 
             //TODO : loadAttributes
+            List attributesYAML = this.collectAllElement((List) classYAML, "attribute");
+            for (Object attributeYAML : attributesYAML) {
+                ObjectModelAttributeImpl attributeOM = loadAttribute(attributeYAML);
+                classOM.addAttribute(attributeOM);
+            }
             //TODO : loadOperations
 
-
-            this.model.addClass(_classOM);
+            //this.modelOM.addClass(classOM);
+            return classOM;
         } else {
             ;//TODO : lever exception
+            return null;
         }
     }
 
@@ -122,64 +189,204 @@
         ;//TODO
     }
 
-    public void loadAttribute(Object _attribute) {
-        ;//TODO
+    public ObjectModelAttributeImpl loadAttribute(Object attributeYAML) {
+        if(attributeYAML instanceof List)
+        {
+            ObjectModelAttributeImpl attributeOM = new ObjectModelAttributeImpl();
+
+            this.loadStereotypes((List) attributeYAML, attributeOM);
+            this.loadTagValues((List) attributeYAML, attributeOM);
+            this.loadComments((List) attributeYAML, attributeOM);
+
+            Object nameYAML = collectElement((List) attributeYAML, "name");
+            if(nameYAML != null)
+            {
+                attributeOM.setName(String.valueOf(nameYAML));
+            }
+            else
+            {
+                //TODO : charger la valeur par defaut
+            }
+
+            Object typeYAML = collectElement((List) attributeYAML, "type");
+            if(typeYAML != null)
+            {
+                //TODO : gerer les imports et detection des types primitifs...
+                String type = String.valueOf(typeYAML);
+                if(imports.containsKey(type))
+                {
+                    attributeOM.setType(imports.get(type));
+                }
+                else
+                {
+                    attributeOM.setType(type);
+                }
+            }
+            else
+            {
+                ;//TODO : lever exception
+            }
+
+            Object visibilityYAML = collectElement((List) attributeYAML, "visibility");
+            if(visibilityYAML != null)
+            {
+                attributeOM.setVisibility(String.valueOf(visibilityYAML));
+            }
+            else
+            {
+                //TODO : charger valeur par defaut
+            }
+
+            Object staticYAML = collectElement((List) attributeYAML, "static");
+            if(staticYAML != null)
+            {
+                attributeOM.setStatic(Boolean.valueOf(String.valueOf(staticYAML)));//tester boolean ?
+            }
+            else
+            {
+                //TODO : charger valeur par defaut
+            }
+
+            Object finalYAML = collectElement((List) attributeYAML, "final");
+            if(finalYAML != null)
+            {
+                attributeOM.setFinal(Boolean.valueOf(String.valueOf(finalYAML)));
+            }
+            else
+            {
+                //TODO : charger la valeur par defaut
+            }
+
+            Object associationTypeYAML = collectElement((List) attributeYAML, "asociationType");
+            if(associationTypeYAML != null)
+            {
+                attributeOM.setAssociationType(String.valueOf(associationTypeYAML));
+            }
+            else
+            {
+                //TODO : charger la valeur par defaut
+            }
+
+            Object minMultiplicityYAML = collectElement((List) attributeYAML, "minMultiplicity");
+            if(minMultiplicityYAML != null)
+            {
+                attributeOM.setMinMultiplicity(Integer.valueOf(String.valueOf(minMultiplicityYAML)));
+            }
+            else
+            {
+                //TODO : charger la valeur par defaut
+            }
+
+            Object maxMultiplicityYAML = collectElement((List) attributeYAML, "maxMultiplicity");
+            if(maxMultiplicityYAML != null)
+            {
+                attributeOM.setMaxMultiplicity(Integer.valueOf(String.valueOf(maxMultiplicityYAML)));
+            }
+            else
+            {
+                //TODO : charger la valeur par defaut
+            }
+
+            Object navigableYAML = collectElement((List) attributeYAML, "navigable");
+            if(navigableYAML != null)
+            {
+                attributeOM.setNavigable(Boolean.valueOf(String.valueOf(navigableYAML)));
+            }
+            else
+            {
+                //TODO : charger la valeur par defaut
+            }
+
+            Object orderingYAML = collectElement((List) attributeYAML, "ordering");
+            if(orderingYAML != null)
+            {
+                attributeOM.setOrdering(String.valueOf(orderingYAML));
+            }
+            else
+            {
+                //TODO : charger la valeur par defaut
+            }
+
+            Object labelYAML = collectElement((List) attributeYAML, "label");
+            if(labelYAML != null)
+            {
+                //TODO : gestion des labels et operations correspondantes
+                writeLog("label="+String.valueOf(labelYAML));
+            }
+
+            return attributeOM;
+        }
+        return null;
     }
 
-    public void loadOperation(Object _operation) {
+    public void loadOperation(Object operationYAML) {
         ;//TODO
     }
 
-    public void loadStereotypes(List _data, ObjectModelElementImpl _element) {
-        Object stereotypes = this.collectElement(_data, "stereotype");
+    public void loadImports()
+    {   //pour etre sur que les imports seront des <String,String>
+        if(modelYAML instanceof List)//verification inutile ?
+        {
+            Map<Object,Object> tmp = collectMap((List) modelYAML,"imports");
+            imports = new LinkedHashMap();
+            for(Map.Entry<Object,Object> entry : tmp.entrySet())
+            {
+                imports.put(String.valueOf(entry.getKey()),String.valueOf(entry.getValue()));
+            }
+            writeLog("imports="+imports);
+        }
+    }
+
+    public void loadStereotypes(List elementYAML, ObjectModelElementImpl elementOM) {
+        Object stereotypes = this.collectElement(elementYAML, "stereotype");
         if (stereotypes instanceof List) {
             for (Object stereotype : (List) stereotypes) {
                 ObjectModelImplRef ref = new ObjectModelImplRef();
                 ref.setName(String.valueOf(stereotype));
-                _element.addStereotype(ref);
+                elementOM.addStereotype(ref);
             }
         }
     }
 
     //TODO : pour model
-    public void loadComments(List _data, ObjectModelElementImpl _element) {
-        Object comments = this.collectElement(_data, "comments");
+    public void loadComments(List elementYAML, ObjectModelElementImpl elementOM) {
+        Object comments = this.collectElement(elementYAML, "comments");
         if (comments instanceof List) {
             for (Object comment : (List) comments) {
-                _element.addComment(String.valueOf(comment));
+                elementOM.addComment(String.valueOf(comment));
             }
         }
     }
 
     //TODO : pour model
-    public void loadTagValues(List _data, ObjectModelElementImpl _element) {
-        Object tagValues = this.collectElement(_data, "tagValues");
+    public void loadTagValues(List elementYAML, ObjectModelElementImpl elementOM) {
+        Object tagValues = this.collectElement(elementYAML, "tagValues");
         if (tagValues instanceof Map) {
             for (Object entry : ((Map) tagValues).entrySet()) {
                 String key = String.valueOf(((Map.Entry) entry).getKey());
                 String value = String.valueOf(((Map.Entry) entry).getValue());
-                _element.addTagValue(key, value);
+                elementOM.addTagValue(key, value);
             }
         }
     }
 
-    public Object collectElement(List _data, Object _key) {
-        for (Object obj : _data) {
+    public Object collectElement(List data, Object key) {
+        for (Object obj : data) {
             if (obj instanceof Map) {
-                if (((Map) obj).containsKey(_key)) {
-                    return ((Map) obj).get(_key);
+                if (((Map) obj).containsKey(key)) {
+                    return ((Map) obj).get(key);
                 }
             }
         }
         return null;
     }
 
-    public List collectList(List _data, Object _key) {
-        for (Object obj : _data) {
+    public List collectList(List data, Object key) {
+        for (Object obj : data) {
             if (obj instanceof Map) {
-                if (((Map) obj).containsKey(_key)) {
-                    if (((Map) obj).get(_key) instanceof List) {
-                        return (List) ((Map) obj).get(_key);
+                if (((Map) obj).containsKey(key)) {
+                    if (((Map) obj).get(key) instanceof List) {
+                        return (List) ((Map) obj).get(key);
                         /*List res = new LinkedList();
                         for(Object tmp : (List) ((Map) obj).get(_key))
                         {
@@ -193,12 +400,12 @@
         return null;
     }
 
-    public Map collectMap(List _data, Object _key) {
-        for (Object obj : _data) {
+    public Map collectMap(List data, Object key) {
+        for (Object obj : data) {
             if (obj instanceof Map) {
-                if (((Map) obj).containsKey(_key)) {
-                    if (((Map) obj).get(_key) instanceof Map) {
-                        return (Map) ((Map) obj).get(_key);
+                if (((Map) obj).containsKey(key)) {
+                    if (((Map) obj).get(key) instanceof Map) {
+                        return (Map) ((Map) obj).get(key);
                         /*Map res = new LinkedHashMap();
                         for(Object tmp : ((Map) ((Map) obj).get(_key)).entrySet())
                         {
@@ -215,12 +422,13 @@
         return null;
     }
 
-    public List collectAllElement(List _data, Object _key) {
+    //collectElements
+    public List collectAllElement(List data, Object key) {
         List res = new LinkedList();
-        for (Object obj : _data) {
+        for (Object obj : data) {
             if (obj instanceof Map) {
-                if (((Map) obj).containsKey(_key)) {
-                    res.add(((Map) obj).get(_key));
+                if (((Map) obj).containsKey(key)) {
+                    res.add(((Map) obj).get(key));
                 }
             }
         }

    

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

agiraudet＠users.nuiton.org