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