This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository eugene. See https://gitlab.nuiton.org/nuiton/eugene.git commit 9b821a499f4f19bdf36e5c0acb3488496fe45300 Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Sep 10 11:40:22 2016 +0200 Introduce the new mojo to transform old object model extension files to new format (Fixes #4016) --- .../TransformFlatPropertiesToCompactMojo.java | 438 +++++++++++++++++++++ 1 file changed, 438 insertions(+) diff --git a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/TransformFlatPropertiesToCompactMojo.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/TransformFlatPropertiesToCompactMojo.java new file mode 100644 index 0000000..e5ea74f --- /dev/null +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/TransformFlatPropertiesToCompactMojo.java @@ -0,0 +1,438 @@ +package org.nuiton.eugene.plugin; + +import com.google.common.io.Files; +import org.apache.commons.io.IOUtils; +import org.apache.commons.lang3.SystemUtils; +import org.apache.maven.plugins.annotations.Mojo; +import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.plugins.annotations.ResolutionScope; +import org.apache.maven.project.MavenProject; +import org.nuiton.eugene.models.object.reader.extension.ModelExtensionFileParser; +import org.nuiton.eugene.models.object.reader.extension.ModelExtensionFileParserCallback; +import org.nuiton.eugene.models.object.reader.extension.ModelExtensionFileParserFactory; +import org.nuiton.eugene.models.stereotype.InvalidStereotypeSyntaxException; +import org.nuiton.eugene.models.stereotype.StereotypeAble; +import org.nuiton.eugene.models.tagvalue.InvalidTagValueSyntaxException; +import org.nuiton.eugene.models.tagvalue.TagValueAble; +import org.nuiton.plugin.AbstractPlugin; + +import java.io.File; +import java.io.FilenameFilter; +import java.io.IOException; +import java.io.Writer; +import java.nio.charset.StandardCharsets; +import java.util.Map; +import java.util.Set; +import java.util.TreeMap; +import java.util.TreeSet; + +/** + * Created on 09/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +@Mojo(name = "transform-flat-properties-to-compact", requiresDependencyResolution = ResolutionScope.COMPILE) +public class TransformFlatPropertiesToCompactMojo extends AbstractPlugin { + + /** + * Pour activer le mode verbeux. + * + * @since 2.0.0 + */ + @Parameter(property = "eugene.verbose", defaultValue = "${maven.verbose}") + protected boolean verbose; + + /** + * Encoding to be used for generation of files. + * + * <b>Note:</b> If nothing is filled here, we will use the system + * property {@code file.encoding}. + * + * @since 2.0.0 + */ + @Parameter(property = "eugene.encoding", defaultValue = "${project.build.sourceEncoding}") + protected String encoding; + + /** + * Ne génère rien, analyse juste la configuration. + * + * @since 2.0.0 + */ + @Parameter(property = "eugene.dryRun", defaultValue = "false") + protected boolean dryRun; + + /** + * Maven project. + * + * @since 2.0.0 + */ + @Parameter(defaultValue = "${project}", readonly = true) + protected MavenProject project; + + /** + * The type of model to be used. + * + * By default, use an {@code objectmodel}. + * + * @required + */ + @Parameter(property = "eugene.modelType", defaultValue = "xmlobjectmodel", required = true) + protected String modelType; + + /** + * Where to find model properties files. + */ + @Parameter(property = "eugene.inputDirectory", defaultValue = "${project.basedir}/src/main/xmi", required = true) + protected File inputDirectory; + + /** + * Where to generate yaml file. + */ + @Parameter(property = "eugene.outputDirectory", defaultValue = "${project.basedir}/src/main/xmi", required = true) + protected File outputDirectory; + + @Parameter(property = "eugene.modelName", required = true) + protected String modelName; + + protected File[] inputFiles; + protected File outputFile; + protected String eol; + + @Override + protected void init() throws Exception { + + inputFiles = inputDirectory.listFiles(new FilenameFilter() { + @Override + public boolean accept(File dir, String name) { + return name.endsWith(".properties"); + } + }); + + getLog().info("Found " + inputFiles.length + " model extension properties file(s)."); + + outputFile = new File(outputDirectory, modelName + ".objectmodel-ext"); + + } + + @Override + protected void doAction() throws Exception { + + ModelBeanBuilder modelBeanBuilder = new ModelBeanBuilder(modelName); + + for (File inputFile : inputFiles) { + + modelBeanBuilder.addFile(inputFile); + } + + eol = SystemUtils.LINE_SEPARATOR; + ModelBean modelBean = modelBeanBuilder.build(); + + StringBuilder result = new StringBuilder(); + + result.append("[model]").append(eol); + appendMap(modelBean.tagValues, "", "tagvalues", result); + appendSet(modelBean.stereotypes, "", "stereotypes", result); + + result.append(eol).append("[package]").append(eol); + + if (modelBean.withPackages()) { + + for (PackageBean packageBean : modelBean.packages) { + + result.append(packageBean.name).append(eol); + appendMap(packageBean.tagValues, " ", "tagvalues", result); + appendSet(packageBean.stereotypes, " ", "stereotypes", result); + + } + + } + + result.append(eol).append("[class]").append(eol); + + if (modelBean.withClasses()) { + + for (ClassBean classBean : modelBean.classes) { + + result.append(classBean.name).append(eol); + appendMap(classBean.tagValues, " ", "tagvalues", result); + appendSet(classBean.stereotypes, " ", "stereotypes", result); + appendMap(classBean.getAttributesTagValues(), " ", "attributes.tagvalues", result); + appendSet(classBean.getAttributesStereotypes(), " ", "attributes.stereotypes", result); + + } + + } + + if (dryRun) { + + getLog().info("\n\nDryRun mode\ncontent:\n\n" + result.toString() + "\n\n"); + } else { + + getLog().info("Generate to: " + outputFile); + Writer writer = Files.newWriter(outputFile, StandardCharsets.UTF_8); + try { + + IOUtils.write(result.toString(), writer); + writer.close(); + + } finally { + IOUtils.closeQuietly(writer); + } + + } + + } + + protected void appendMap(Map<String, String> map, String prefix, String name, StringBuilder result) { + if (!map.isEmpty()) { + for (Map.Entry<String, String> entry : map.entrySet()) { + result.append(prefix).append(entry.getKey()).append(" ").append(entry.getValue()).append(eol); + } + } + } + + protected void appendSet(Set<String> set, String prefix, String name, StringBuilder result) { + if (!set.isEmpty()) { + for (String stereotype : set) { + result.append(prefix).append(stereotype).append(eol); + } + } + } + + @Override + public MavenProject getProject() { + return project; + } + + @Override + public void setProject(MavenProject project) { + this.project = project; + } + + @Override + public boolean isVerbose() { + return verbose; + } + + @Override + public void setVerbose(boolean verbose) { + this.verbose = verbose; + } + + public static class ModelBean extends ElementBean { + + Set<PackageBean> packages = new TreeSet<>(); + Set<ClassBean> classes = new TreeSet<>(); + + public ModelBean(String name) { + super(name); + } + + @Override + public boolean isEmpty() { + return super.isEmpty() && classes.isEmpty() && packages.isEmpty(); + } + + public PackageBean getOrCreatePackage(final String packageName) { + + PackageBean result = null; + for (PackageBean packageBean : packages) { + if (packageName.equals(packageBean.name)) { + result = packageBean; + break; + } + } + if (result == null) { + result = new PackageBean(packageName); + packages.add(result); + } + return result; + } + + public ClassBean getOrCreateClass(final String className) { + + ClassBean result = null; + for (ClassBean packageBean : classes) { + if (className.equals(packageBean.name)) { + result = packageBean; + break; + } + } + if (result == null) { + result = new ClassBean(className); + classes.add(result); + } + return result; + } + + public AttributeBean getOrCreateClassAttribute(String className, String attributeName) { + ClassBean classBean = getOrCreateClass(className); + return classBean.getOrCreateAttribute(attributeName); + } + + public boolean withClasses() { + return !classes.isEmpty(); + } + + public boolean withPackages() { + return !packages.isEmpty(); + } + } + + public static class PackageBean extends ElementBean { + + public PackageBean(String name) { + super(name); + } + + } + + public static class ClassBean extends ElementBean { + + Set<AttributeBean> attributes = new TreeSet<>(); + + public ClassBean(String name) { + super(name); + } + + @Override + public boolean isEmpty() { + return super.isEmpty() && attributes.isEmpty(); + } + + public Map<String, String> getAttributesTagValues() { + Map<String, String> attributesTagValues = new TreeMap<>(); + for (AttributeBean attributeBean : attributes) { + + for (Map.Entry<String, String> entry : attributeBean.tagValues.entrySet()) { + attributesTagValues.put(attributeBean.name + "." + entry.getKey(), entry.getValue()); + } + } + return attributesTagValues; + } + + public Set<String> getAttributesStereotypes() { + Set<String> attributesStereotypes = new TreeSet<>(); + for (AttributeBean attributeBean : attributes) { + + for (String entry : attributeBean.stereotypes) { + attributesStereotypes.add(attributeBean.name + "." + entry); + } + } + return attributesStereotypes; + } + + public AttributeBean getOrCreateAttribute(String attributeName) { + AttributeBean result = null; + for (AttributeBean attributeBean : attributes) { + if (attributeName.equals(attributeBean.name)) { + result = attributeBean; + break; + } + } + if (result == null) { + result = new AttributeBean(attributeName); + attributes.add(result); + } + return result; + } + } + + public static class AttributeBean extends ElementBean { + + public AttributeBean(String name) { + super(name); + } + } + + public static class ElementBean implements Comparable<ElementBean> { + final String name; + final Map<String, String> tagValues = new TreeMap<>(); + final Set<String> stereotypes = new TreeSet<>(); + + public ElementBean(String name) { + this.name = name; + } + + @Override + public int compareTo(ElementBean o) { + return name.compareTo(o.name); + } + + public <T extends TagValueAble & StereotypeAble> void load(T tag) { + this.tagValues.putAll(tag.getTagValues()); + this.stereotypes.addAll(tag.getStereotypes()); + } + + public boolean isEmpty() { + return tagValues.isEmpty() && stereotypes.isEmpty(); + } + } + + private static class ModelBeanBuilder implements ModelExtensionFileParserCallback { + + private final ModelExtensionFileParser parser; + private final ModelBean modelBean; + + public ModelBeanBuilder(String modelName) { + this.parser = ModelExtensionFileParserFactory.newFlatPaser(); + this.modelBean = new ModelBean(modelName); + } + + public ModelBean build() { + return modelBean; + } + + @Override + public boolean onModelTagValueFound(String tag, String value) { + modelBean.tagValues.put(tag, value); + return true; + } + + @Override + public boolean onModelStereotypeFound(String stereotype) { + modelBean.stereotypes.add(stereotype); + return true; + } + + @Override + public boolean onPackageTagValueFound(String packageName, String tag, String value) { + modelBean.getOrCreatePackage(packageName).tagValues.put(tag, value); + return true; + } + + @Override + public boolean onPackageStereotypeFound(String packageName, String stereotype) { + modelBean.getOrCreatePackage(packageName).stereotypes.add(stereotype); + return true; + } + + @Override + public boolean onClassTagValueFound(String className, String tag, String value) { + modelBean.getOrCreateClass(className).tagValues.put(tag, value); + return true; + } + + @Override + public boolean onClassStereotypeFound(String className, String stereotype) { + modelBean.getOrCreateClass(className).stereotypes.add(stereotype); + return true; + } + + @Override + public boolean onAttributeTagValueFound(String className, String attributeName, String tag, String value) { + modelBean.getOrCreateClassAttribute(className, attributeName).tagValues.put(tag, value); + return true; + } + + @Override + public boolean onAttributeStereotypeFound(String className, String attributeName, String stereotype) { + modelBean.getOrCreateClassAttribute(className, attributeName).stereotypes.add(stereotype); + return true; + } + + public void addFile(File inputFile) throws InvalidTagValueSyntaxException, InvalidStereotypeSyntaxException, IOException { + parser.parse(inputFile, this); + } + } +} -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.