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 13ada7b7163908c4d0c5ca91252276d45aad81a3 Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Sep 26 12:29:09 2016 +0200 Rethink stereotypes and tag values API (See #4042) --- eugene-java-templates/pom.xml | 5 + .../eugene/java/AbstractJavaBeanTransformer.java | 19 +- .../nuiton/eugene/java/EugeneJavaStereoTypes.java | 410 ++++++++++++ .../nuiton/eugene/java/EugeneJavaTagValues.java | 713 +++++++++++++++++++++ .../eugene/java/JavaEnumerationTransformer.java | 4 +- .../eugene/java/JavaTemplatesStereoTypes.java | 2 +- .../SimpleJavaBeanWithNoInterfaceTransformer.java | 4 +- ...stereotype.provider.StereotypeMetadatasProvider | 1 + ...ion.tagvalue.provider.TagValueMetadatasProvider | 1 + .../eugene/java/EugeneJavaStereoTypesTest.java | 80 +++ .../eugene/java/EugeneJavaTagValuesTest.java | 71 ++ .../org/nuiton/eugene/plugin/GenerateMojo.java | 94 +-- .../eugene/plugin/modelextension/ElementBean.java | 4 +- .../plugin/modelextension/ModelBeanBuilder.java | 4 +- .../writer/BaseChainedFileWriterToMemoryModel.java | 28 +- .../org/nuiton/eugene/EugeneCoreStereotypes.java | 133 ++++ .../org/nuiton/eugene/EugeneCoreTagValues.java | 236 +++++++ .../java/org/nuiton/eugene/EugeneStereoTypes.java | 1 + .../java/org/nuiton/eugene/EugeneTagValues.java | 1 + .../main/java/org/nuiton/eugene/GeneratorUtil.java | 6 +- .../main/java/org/nuiton/eugene/ModelReader.java | 28 +- .../org/nuiton/eugene/java/JavaGeneratorUtil.java | 8 +- .../eugene/java/ObjectModelTransformerToJava.java | 36 +- .../main/java/org/nuiton/eugene/models/Model.java | 4 +- .../InvalidStereotypeSyntaxException.java | 4 +- .../MismatchStereotypeTargetException.java | 4 +- .../stereotype/MissingStereoTypeException.java | 36 +- .../extension/stereotype/StereotypeMetadata.java | 40 ++ ...tereotypeMetadatasProviderManagerExtension.java | 42 ++ .../stereotype/StereotypeNotFoundException.java | 4 +- .../stereotype/StereotypeUtil.java} | 137 ++-- .../stereotype/WithStereotypes.java} | 6 +- .../AggregateStereotypeMetadatasProvider.java | 113 ++++ .../DefaultStereotypeMetadatasProvider.java | 62 ++ .../provider/StereotypeMetadatasProvider.java | 23 + .../tagvalue/InvalidTagValueSyntaxException.java | 2 +- .../tagvalue/MismatchTagValueTargetException.java | 2 +- .../tagvalue/MissingTagValueException.java | 43 +- .../extension/tagvalue/TagValueMetadata.java | 51 ++ .../TagValueMetadatasProviderManagerExtension.java | 42 ++ .../tagvalue/TagValueNotFoundException.java | 2 +- .../models/extension/tagvalue/TagValueUtil.java | 193 ++++++ .../tagvalue/WithTagValues.java} | 7 +- .../matcher/EqualsTagValueNameMatcher.java | 12 +- .../tagvalue/matcher/StartsWithTagNameMatcher.java | 12 +- .../matcher/TagValueDefinitionMatcher.java | 24 +- .../AggregateTagValueMetadatasProvider.java | 91 +++ .../provider/DefaultTagValueMetadatasProvider.java | 81 +++ .../provider/TagValueMetadatasProvider.java | 23 + .../eugene/models/object/ObjectModelElement.java | 4 +- .../eugene/models/object/ObjectModelPackage.java | 6 +- .../object/reader/AbstractObjectModelReader.java | 79 ++- .../extension/FlatModelExtensionFileParser.java | 17 +- .../reader/extension/LoadModelExtension.java | 74 ++- .../reader/extension/ModelExtensionFileParser.java | 5 +- .../object/xml/ObjectModelAttributeImpl.java | 4 +- .../models/object/xml/ObjectModelElementImpl.java | 16 +- .../eugene/models/object/xml/ObjectModelImpl.java | 46 ++ .../models/object/xml/ObjectModelPackageImpl.java | 10 + .../eugene/models/state/xml/StateModelImpl.java | 10 + .../AggregateStereotypeDefinitionProvider.java | 1 + .../InvalidStereotypeSyntaxException.java | 1 + .../MismatchStereotypeTargetException.java | 1 + .../stereotype/MissingStereoTypeException.java | 1 + .../stereotype/MyStereotypeDefinitionProvider.java | 1 + .../eugene/models/stereotype/StereotypeAble.java | 1 + .../models/stereotype/StereotypeDefinition.java | 1 + .../stereotype/StereotypeDefinitionProvider.java | 1 + ...ereotypeDefinitionProviderManagerExtension.java | 1 + .../stereotype/StereotypeDefinitionProviders.java | 1 + .../stereotype/StereotypeNotFoundException.java | 1 + .../eugene/models/stereotype/Stereotypes.java | 1 + .../eugene/models/stereotype/package-info.java | 1 + .../AggregateTagValueDefinitionProvider.java | 1 + .../tagvalue/InvalidTagValueSyntaxException.java | 1 + .../tagvalue/MismatchTagValueTargetException.java | 1 + .../models/tagvalue/MissingTagValueException.java | 1 + .../eugene/models/tagvalue/TagValueAble.java | 1 + .../eugene/models/tagvalue/TagValueDefinition.java | 1 + .../tagvalue/TagValueDefinitionProvider.java | 1 + ...TagValueDefinitionProviderManagerExtension.java | 1 + .../tagvalue/TagValueDefinitionProviders.java | 1 + .../models/tagvalue/TagValueNotFoundException.java | 1 + .../nuiton/eugene/models/tagvalue/TagValues.java | 1 + .../matcher/EqualsTagValueNameMatcher.java | 1 + .../tagvalue/matcher/StartsWithTagNameMatcher.java | 1 + .../matcher/TagValueDefinitionMatcher.java | 1 + .../eugene/models/tagvalue/package-info.java | 1 + ...stereotype.provider.StereotypeMetadatasProvider | 1 + ...ion.tagvalue.provider.TagValueMetadatasProvider | 1 + .../nuiton/eugene/EugeneCoreStereotypesTest.java | 52 ++ .../org/nuiton/eugene/EugeneCoreTagValuesTest.java | 68 ++ .../models/object/XMI21ToObjectModelTest.java | 5 +- 93 files changed, 3027 insertions(+), 348 deletions(-) diff --git a/eugene-java-templates/pom.xml b/eugene-java-templates/pom.xml index 1c2950f..555e662 100644 --- a/eugene-java-templates/pom.xml +++ b/eugene-java-templates/pom.xml @@ -76,6 +76,11 @@ </dependency> <dependency> + <groupId>org.nuiton.i18n</groupId> + <artifactId>nuiton-i18n</artifactId> + </dependency> + + <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> </dependency> diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java index 78dddcf..87eb128 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java @@ -29,7 +29,6 @@ package org.nuiton.eugene.java; import org.apache.commons.lang3.StringUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.nuiton.eugene.EugeneTagValues; import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.models.object.ObjectModelAttribute; import org.nuiton.eugene.models.object.ObjectModelClass; @@ -61,19 +60,19 @@ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformer /** Logger. */ private static final Log log = LogFactory.getLog(AbstractJavaBeanTransformer.class); - private JavaTemplatesTagValues javaTemplatesTagValues; - private JavaTemplatesStereoTypes javaTemplatesStereoTypes; + private EugeneJavaTagValues javaTemplatesTagValues; + private EugeneJavaStereoTypes javaTemplatesStereoTypes; - public JavaTemplatesTagValues getJavaTemplatesTagValues() { + public EugeneJavaTagValues getJavaTemplatesTagValues() { if (javaTemplatesTagValues == null) { - javaTemplatesTagValues = getTagValueDefinitionProvider(JavaTemplatesTagValues.class); + javaTemplatesTagValues = getTagValueMetadatasProvider(EugeneJavaTagValues.class); } return javaTemplatesTagValues; } - public JavaTemplatesStereoTypes getJavaTemplatesStereoTypes() { + public EugeneJavaStereoTypes getJavaTemplatesStereoTypes() { if (javaTemplatesStereoTypes == null) { - javaTemplatesStereoTypes = getStereotypeDefinitionProvider(JavaTemplatesStereoTypes.class); + javaTemplatesStereoTypes = getStereotypeMetadatasProvider(EugeneJavaStereoTypes.class); } return javaTemplatesStereoTypes; } @@ -788,9 +787,9 @@ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformer ObjectModelClass input, ObjectModelClassifier output) { - String i18nPrefix = getTagValueDefinitionProvider(EugeneTagValues.class).getI18nPrefixTagValue(input, - aPackage, - model); + String i18nPrefix = getEugeneTagValues().getI18nPrefixTagValue(input, + aPackage, + model); if (!StringUtils.isEmpty(i18nPrefix)) { generateI18nBlock(input, output, i18nPrefix); } diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/EugeneJavaStereoTypes.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/EugeneJavaStereoTypes.java new file mode 100644 index 0000000..125b674 --- /dev/null +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/EugeneJavaStereoTypes.java @@ -0,0 +1,410 @@ +package org.nuiton.eugene.java; + +/* + * #%L + * EUGene :: Java templates + * %% + * Copyright (C) 2012 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 com.google.common.collect.ImmutableSet; +import org.nuiton.eugene.models.extension.stereotype.StereotypeMetadata; +import org.nuiton.eugene.models.extension.stereotype.StereotypeUtil; +import org.nuiton.eugene.models.extension.stereotype.provider.DefaultStereotypeMetadatasProvider; +import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelPackage; + +import java.util.Set; + +import static org.nuiton.i18n.I18n.n; + +/** + * Defines all stereotypes managed by Java templates. + * + * @author Tony Chemit - chemit@codelutin.com + * @plexus.component role="org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider" role-hint="eugene-java-templates" + * @since 2.5.6 + */ +public class EugeneJavaStereoTypes extends DefaultStereotypeMetadatasProvider { + + public enum Store implements StereotypeMetadata { + + /** + * Stereotype for JavaBean objects to place on a classifier. + * + * @see #hasBeanStereotype(ObjectModelClassifier, ObjectModelPackage) + * @see #hasBeanStereotype(ObjectModelPackage) + * @since 2.5.6 + */ + bean(n("eugene.java.stereotype.bean"), ObjectModelClassifier.class, ObjectModelPackage.class), + + /** + * Tag value to authorize user to generate some bean with methods, some generators won't generate them : Lots code). + * + * By default, user should never add methods in bean classes, simply write them in your java code!. + * + * You can globaly use it on the complete model, on packages, or to a specific classifier. + * + * @see #isAcceptBeanWithMethods(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + acceptBeanWithMethods(n("eugene.java.stereotype.acceptBeanWithMethods"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + + /** + * Tag value to authorize user to override abstract classes. + * + * By default, user should never override abstract classes but works on implementation ones. + * + * You can globaly use it on the complete model, on packages, or to a specific classifier. + * + * @see #isOverrideAbstractClasses(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + overrideAbstractClasses(n("eugene.java.stereotype.overrideAbstractClasses"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * Tag value to generate property change support on generated beans. + * + * You can globaly use it on the complete model, on packages, or to a specific classifier. + * + * @see #isSkipGeneratePropertyChangeSupport(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.12 + */ + generatePropertyChangeSupport(n("eugene.java.stereotype.generatePropertyChangeSupport"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * Tag value to generate lazy instanciation of any collection to avoid NPEs. + * + * You can globaly use it on the complete model or a package, or to a specific classifier. + * + * @see #isSkipGenerateNotEmptyCollections(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.12 + */ + generateNotEmptyCollections(n("eugene.java.stereotype.generateNotEmptyCollections"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To generate an interface of each simple bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #isSimpleBeanSkipGenerateInterface(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.6.2 + */ + simpleBeanGenerateInterface(n("eugene.java.stereotype.simpleBeanGenerateInterface"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To generate a factory of generated simple beans. + * + * You must use it on the complete model. + * + * @see #isSimpleBeanSkipGenerateFactory(ObjectModel) + * @since 2.6.2 + */ + simpleBeanGenerateFactory(n("eugene.java.stereotype.simpleBeanGenerateFactory"), ObjectModel.class), + + /** + * To generate a factory of generated simple beans. + * + * You must use it on the complete model. + * + * @see #isSimpleBeanSkipGenerateDefaults(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.7.2 + */ + simpleBeanGenerateDefaults(n("eugene.java.stereotype.simpleBeanGenerateDefaults"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To generate a factory of generated simple beans. + * + * You must use it on the complete model. + * + * @see #isSimpleBeanWithNoInterfaceSkipGenerateDefaults(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + simpleBeanWithNoInterfaceGenerateDefaults(n("eugene.java.stereotype.simpleBeanWithNoInterfaceGenerateDefaults"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + + /** + * To generate or not guava predicates on each property of the bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #isSimpleBeanWithNoInterfaceSkipGeneratePredicates(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + simpleBeanWithNoInterfaceGeneratePredicates(n("eugene.java.stereotype.simpleBeanWithNoInterfaceGeneratePredicates"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To generate or not guava functions on each property of the bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #isSimpleBeanWithNoInterfaceSkipGenerateFunctions(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + simpleBeanWithNoInterfaceGenerateFunctions(n("eugene.java.stereotype.simpleBeanWithNoInterfaceGenerateFunctions"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To generate or not constructors methods on Default classes. + * + * You can globaly use it on the complete model, package or on a specific classifier. + * + * @see #isSimpleBeanWithNoInterfaceSkipGenerateDefaultConstructors(ObjectModelClassifier, ObjectModelPackage, ObjectModel)} + * @since 3.0 + */ + simpleBeanWithNoInterfaceSkipGenerateConstructors(n("eugene.java.stereotype.simpleBeanWithNoInterfaceSkipGenerateConstructors"), ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class); + + + private final Set<Class<?>> targets; + private final String i18nDocumentationKey; + + Store(String i18nDocumentationKey, Class<?>... targets) { + this.targets = ImmutableSet.copyOf(targets); + this.i18nDocumentationKey = i18nDocumentationKey; + } + + @Override + public String getName() { + return name(); + } + + @Override + public Set<Class<?>> getTargets() { + return targets; + } + + @Override + public String getI18nDocumentationKey() { + return i18nDocumentationKey; + } + + @Override + public boolean isDeprecated() { + return false; + } + } + + public EugeneJavaStereoTypes() { + super((StereotypeMetadata[]) Store.values()); + } + + /** + * Check if the given classifier has the {@link Store#bean} stereotype. + * + * @param classifier classifier to test + * @return {@code true} if stereotype was found, {@code false otherwise} + * @see Store#bean + */ + public static boolean hasBeanStereotype(ObjectModelClassifier classifier, ObjectModelPackage aPackage) { + return StereotypeUtil.findDirectStereotype(Store.bean, classifier, aPackage); + } + + /** + * Check if the given aPackage has the {@link Store#bean} stereotype. + * + * @param aPackage classifier to test + * @return {@code true} if stereotype was found, {@code false otherwise} + * @see Store#bean + */ + public static boolean hasBeanStereotype(ObjectModelPackage aPackage) { + return StereotypeUtil.findDirectStereotype(Store.bean, aPackage); + } + + /** + * Obtain the value of the {@link Store#acceptBeanWithMethods} tag value on the given model, package or classifier. + * + * It will first look on the model, then and package and then in the given classifier. + * + * If no value found, then will use the default value of the tag value. + * + * @param classifier classifier to seek + * @param aPackage package to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#acceptBeanWithMethods + * @since 3.0 + */ + public boolean isAcceptBeanWithMethods(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.acceptBeanWithMethods, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#overrideAbstractClasses} tag value on the given model, package or classifier. + * + * It will first look on the model, then and package and then in the given classifier. + * + * If no value found, then will use the default value of the tag value. + * + * @param classifier classifier to seek + * @param aPackage package to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#overrideAbstractClasses + * @since 3.0 + */ + public boolean isOverrideAbstractClasses(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.overrideAbstractClasses, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#generatePropertyChangeSupport} tag value on the given model, package or classifier. + * + * It will first look on the model, then and package and then in the given classifier. + * + * If no value found, then will use the default value of the tag value. + * + * @param classifier classifier to seek + * @param aPackage package to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#generatePropertyChangeSupport + * @since 2.12 + */ + public boolean isSkipGeneratePropertyChangeSupport(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.generatePropertyChangeSupport, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#generateNotEmptyCollections} tag value on the given model, package or classifier. + * + * It will first look on the model, then and package and then in the given classifier. + * + * If no value found, then will use the default value of the tag value. + * + * @param classifier classifier to seek + * @param aPackage package to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#generateNotEmptyCollections + * @since 2.12 + */ + public boolean isSkipGenerateNotEmptyCollections(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.generateNotEmptyCollections, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanGenerateInterface} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanGenerateInterface + * @since 2.3 + */ + public boolean isSimpleBeanSkipGenerateInterface(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.simpleBeanGenerateInterface, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanGenerateFactory} tag value on the given model or classifier. + * + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanGenerateFactory + * @since 2.7.2 + */ + public boolean isSimpleBeanSkipGenerateFactory(ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.simpleBeanGenerateFactory, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanGenerateDefaults} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanGenerateDefaults + * @since 2.7.2 + */ + public boolean isSimpleBeanSkipGenerateDefaults(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.simpleBeanGenerateDefaults, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceGenerateDefaults} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceGenerateDefaults + * @since 3.0 + */ + public boolean isSimpleBeanWithNoInterfaceSkipGenerateDefaults(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.simpleBeanWithNoInterfaceGenerateDefaults, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceGeneratePredicates} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * <strong>If not filled, then use default {@code s} value.</strong> + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceGeneratePredicates + * @since 3.0 + */ + public boolean isSimpleBeanWithNoInterfaceSkipGeneratePredicates(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.simpleBeanWithNoInterfaceGeneratePredicates, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceGenerateFunctions} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * <strong>If not filled, then use default {@code s} value.</strong> + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceGenerateFunctions + * @since 3.0 + */ + public boolean isSimpleBeanWithNoInterfaceSkipGenerateFunctions(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.simpleBeanWithNoInterfaceGenerateFunctions, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceSkipGenerateConstructors} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * <strong>If not filled, then use default {@code s} value.</strong> + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceSkipGenerateConstructors + * @since 3.0 + */ + public boolean isSimpleBeanWithNoInterfaceSkipGenerateDefaultConstructors(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return StereotypeUtil.findDirectStereotype(Store.simpleBeanWithNoInterfaceSkipGenerateConstructors, classifier, aPackage, model); + } + + +} diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/EugeneJavaTagValues.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/EugeneJavaTagValues.java new file mode 100644 index 0000000..7ca6609 --- /dev/null +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/EugeneJavaTagValues.java @@ -0,0 +1,713 @@ +package org.nuiton.eugene.java; + +/* + * #%L + * EUGene :: Java templates + * %% + * Copyright (C) 2012 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 com.google.common.collect.ImmutableSet; +import org.apache.commons.lang3.StringUtils; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; +import org.nuiton.eugene.models.extension.tagvalue.TagValueUtil; +import org.nuiton.eugene.models.extension.tagvalue.matcher.EqualsTagValueNameMatcher; +import org.nuiton.eugene.models.extension.tagvalue.provider.DefaultTagValueMetadatasProvider; +import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelPackage; + +import java.util.Set; + +import static org.nuiton.i18n.I18n.n; + +/** + * Defines all tag values managed by Java templates. + * + * @author Tony Chemit - chemit@codelutin.com + * @plexus.component role="org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider" role-hint="eugene-java-templates" + * @since 2.5.6 + */ +public class EugeneJavaTagValues extends DefaultTagValueMetadatasProvider { + +// /** +// * Tag value to generate property change support on generated beans. +// * +// * You can globaly use it on the complete model, on packages, or to a specific classifier. +// * +// * @see #isSkipGeneratePropertyChangeSupport(ObjectModelClassifier, ObjectModelPackage, ObjectModel) +// * @since 2.12 +// */ +// @TagValueDefinition( +// target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, +// defaultValue = "true", +// documentation = "To generate property change support code.") +// generatePropertyChangeSupport(n("eugene.java.tagvalue."), String.class, null,ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), +// +// /** +// * Tag value to generate lazy instanciation of any collection to avoid NPEs. +// * +// * You can globaly use it on the complete model or a package, or to a specific classifier. +// * +// * @see #isSkipGenerateNotEmptyCollections(ObjectModelClassifier, ObjectModelPackage, ObjectModel) +// * @since 2.12 +// */ +// @TagValueDefinition( +// target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, +// defaultValue = "true", +// documentation = "To lazy instanciate collections to avoid NPE codes.") +// generateNotEmptyCollections(n("eugene.java.tagvalue."), String.class, null,ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + public enum Store implements TagValueMetadata { + + /** + * Tag value to use a super class for generated bean. + * + * If the bean needs Property change support (says you use the {@link JavaTemplatesStereoTypes#STEREOTYPE_SKIP_GENERATE_PROPERTY_CHANGE_SUPPORT}), + * then your class must provide everything for it. + * + * More over, if you use some collections in your bean you must also define + * two method named {@code getChild(Collection list, int index)} and + * {@code getChild(List list, int index)} + * + * See new code to know minimum stuff to add in your class for this purpose. + * <pre> + * public abstract class AbstractBean implements Serializable { + * + * private static final long serialVersionUID = 1L; + * + * protected final PropertyChangeSupport pcs = new PropertyChangeSupport(this); + * + * public void addPropertyChangeListener(PropertyChangeListener listener) { + * pcs.addPropertyChangeListener(listener); + * } + * + * public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) { + * pcs.addPropertyChangeListener(propertyName, listener); + * } + * + * public void removePropertyChangeListener(PropertyChangeListener listener) { + * pcs.removePropertyChangeListener(listener); + * } + * + * public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) { + * pcs.removePropertyChangeListener(propertyName, listener); + * } + * + * protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) { + * pcs.firePropertyChange(propertyName, oldValue, newValue); + * } + * + * protected void firePropertyChange(String propertyName, Object newValue) { + * firePropertyChange(propertyName, null, newValue); + * } + * + * protected <T> T getChild(Collection<T> list, int index) { + * return CollectionUtil.getOrNull(list, index); + * } + * + * protected <T> T getChild(List<T> list, int index) { + * return CollectionUtil.getOrNull(list, index); + * } + * } + * </pre> + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getBeanSuperClassTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.5.6 + */ + beanSuperClass(n("eugene.java.tagvalue.beanSuperClass"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + /** + * Tag value to use a super class for generated bean. + * + * If the bean needs Property change support (says you use the tag-value {@link JavaTemplatesStereoTypes#STEREOTYPE_SKIP_GENERATE_PROPERTY_CHANGE_SUPPORT}, + * then your class must provide evrything for it. + * + * More over, if you use some collections in your bean you must also define + * two method named {@code getChild(Collection list, int index)} and + * {@code getChild(List list, int index)} + * + * See new code to know minimum stuff to add in your class for this purpose. + * <pre> + * public abstract class AbstractBean implements Serializable { + * + * private static final long serialVersionUID = 1L; + * + * protected final PropertyChangeSupport pcs = new PropertyChangeSupport(this); + * + * public void addPropertyChangeListener(PropertyChangeListener listener) { + * pcs.addPropertyChangeListener(listener); + * } + * + * public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) { + * pcs.addPropertyChangeListener(propertyName, listener); + * } + * + * public void removePropertyChangeListener(PropertyChangeListener listener) { + * pcs.removePropertyChangeListener(listener); + * } + * + * public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) { + * pcs.removePropertyChangeListener(propertyName, listener); + * } + * + * protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) { + * pcs.firePropertyChange(propertyName, oldValue, newValue); + * } + * + * protected void firePropertyChange(String propertyName, Object newValue) { + * firePropertyChange(propertyName, null, newValue); + * } + * + * protected <T> T getChild(Collection<T> list, int index) { + * return CollectionUtil.getOrNull(list, index); + * } + * + * protected <T> T getChild(List<T> list, int index) { + * return CollectionUtil.getOrNull(list, index); + * } + * } + * </pre> + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanSuperClassTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.5.6 + */ + simpleBeanSuperClass(n("eugene.java.tagvalue.simpleBeanSuperClass"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a prefix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanClassNamePrefixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.6.2 + */ + simpleBeanClassNamePrefix(n("eugene.java.tagvalue.simpleBeanClassNamePrefix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a prefix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanClassNameSuffixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.6.2 + */ + simpleBeanClassNameSuffix(n("eugene.java.tagvalue.simpleBeanClassNameSuffix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * Tag value to use a super interface for generated interfaces on simple bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanInterfaceSuperClassTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.6.2 + */ + simpleBeanInterfaceSuperClass(n("eugene.java.tagvalue.simpleBeanInterfaceSuperClass"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a prefix on the name of each generated interface of a simple bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanInterfaceNamePrefixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.6.2 + */ + simpleBeanInterfaceNamePrefix(n("eugene.java.tagvalue.simpleBeanInterfaceNamePrefix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a prefix on the name of each generated interface of a simple bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanInterfaceNameSuffixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.6.2 + */ + simpleBeanInterfaceNameSuffix(n("eugene.java.tagvalue.simpleBeanInterfaceNameSuffix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * Tag value to use a super super-class for generated defaults class of a + * simple bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanDefaultsSuperClassTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.7.2 + */ + simpleBeanDefaultsSuperClass(n("eugene.java.tagvalue.simpleBeanDefaultsSuperClass"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a prefix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanDefaultsClassNamePrefixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.7.2 + */ + simpleBeanDefaultsClassNamePrefix(n("eugene.java.tagvalue.simpleBeanDefaultsClassNamePrefix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a suffix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanDefaultsClassNameSuffixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 2.6.2 + */ + simpleBeanDefaultsClassNameSuffix(n("eugene.java.tagvalue.simpleBeanDefaultsClassNameSuffix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * Tag value to use a super class for generated bean. + * + * If the bean needs Property change support (says you use the tag-value {@link JavaTemplatesStereoTypes#STEREOTYPE_SKIP_GENERATE_PROPERTY_CHANGE_SUPPORT}, + * then your class must provide evrything for it. + * + * More over, if you use some collections in your bean you must also define + * two method named {@code getChild(Collection list, int index)} and + * {@code getChild(List list, int index)} + * + * See new code to know minimum stuff to add in your class for this purpose. + * <pre> + * public abstract class AbstractBean implements Serializable { + * + * private static final long serialVersionUID = 1L; + * + * protected final PropertyChangeSupport pcs = new PropertyChangeSupport(this); + * + * public void addPropertyChangeListener(PropertyChangeListener listener) { + * pcs.addPropertyChangeListener(listener); + * } + * + * public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) { + * pcs.addPropertyChangeListener(propertyName, listener); + * } + * + * public void removePropertyChangeListener(PropertyChangeListener listener) { + * pcs.removePropertyChangeListener(listener); + * } + * + * public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) { + * pcs.removePropertyChangeListener(propertyName, listener); + * } + * + * protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) { + * pcs.firePropertyChange(propertyName, oldValue, newValue); + * } + * + * protected void firePropertyChange(String propertyName, Object newValue) { + * firePropertyChange(propertyName, null, newValue); + * } + * + * protected <T> T getChild(Collection<T> list, int index) { + * return CollectionUtil.getOrNull(list, index); + * } + * + * protected <T> T getChild(List<T> list, int index) { + * return CollectionUtil.getOrNull(list, index); + * } + * } + * </pre> + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanWithNoInterfaceSuperClassTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + simpleBeanWithNoInterfaceSuperClass(n("eugene.java.tagvalue.simpleBeanWithNoInterfaceSuperClass"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * Tag value to use a super super-class for generated defaults class of a simple bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanWithNoInterfaceDefaultsSuperClassTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + simpleBeanWithNoInterfaceDefaultsSuperClass(n("eugene.java.tagvalue.simpleBeanWithNoInterfaceDefaultsSuperClass"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a prefix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanClassNamePrefixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + simpleBeanWithNoInterfaceClassNamePrefix(n("eugene.java.tagvalue.simpleBeanWithNoInterfaceClassNamePrefix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a prefix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanClassNameSuffixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + simpleBeanWithNoInterfaceClassNameSuffix(n("eugene.java.tagvalue.simpleBeanWithNoInterfaceClassNameSuffix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a prefix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanWithNoInterfaceDefaultsClassNamePrefixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + simpleBeanWithNoInterfaceDefaultsClassNamePrefix(n("eugene.java.tagvalue.simpleBeanWithNoInterfaceDefaultsClassNamePrefix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a suffix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanWithNoInterfaceDefaultsClassNameSuffixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + simpleBeanWithNoInterfaceDefaultsClassNameSuffix(n("eugene.java.tagvalue.simpleBeanWithNoInterfaceDefaultsClassNameSuffix"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To use java 8 new syntax and api in generation. + * + * You can globaly use it on the complete model. + * + * @see #isUseJava8(ObjectModel) + * @since 2.15 + */ + java8(n("eugene.java.tagvalue.java8"), boolean.class, "false", ObjectModel.class); + + private final Set<Class<?>> targets; + private final Class<?> type; + private final String i18nDocumentationKey; + private final String defaultValue; + + Store(String i18nDocumentationKey, Class<?> type, String defaultValue, Class<?>... targets) { + this.targets = ImmutableSet.copyOf(targets); + this.type = type; + this.i18nDocumentationKey = i18nDocumentationKey; + this.defaultValue = defaultValue; + } + + @Override + public String getName() { + return name(); + } + + @Override + public Set<Class<?>> getTargets() { + return targets; + } + + @Override + public Class<?> getType() { + return type; + } + + @Override + public Class<EqualsTagValueNameMatcher> getMatcherClass() { + return EqualsTagValueNameMatcher.class; + } + + @Override + public String getI18nDocumentationKey() { + return i18nDocumentationKey; + } + + @Override + public String getDefaultValue() { + return defaultValue; + } + + @Override + public boolean isDeprecated() { + return false; + } + + } + + public EugeneJavaTagValues() { + super((TagValueMetadata[]) Store.values()); + } + + + /** + * Obtain the value of the {@link Store#beanSuperClass} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#beanSuperClass + * @since 2.3 + */ + public String getBeanSuperClassTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.beanSuperClass, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanSuperClass} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanSuperClass + * @since 2.6.2 + */ + public String getSimpleBeanSuperClassTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanSuperClass, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanInterfaceSuperClass} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanInterfaceSuperClass + * @since 2.6.2 + */ + public String getSimpleBeanInterfaceSuperClassTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanInterfaceSuperClass, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanClassNamePrefix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanClassNamePrefix + * @since 2.6.2 + */ + public String getSimpleBeanClassNamePrefixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanClassNamePrefix, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanClassNameSuffix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanClassNameSuffix + * @since 2.6.2 + */ + public String getSimpleBeanClassNameSuffixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanClassNameSuffix, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanInterfaceNamePrefix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanInterfaceNamePrefix + * @since 2.6.2 + */ + public String getSimpleBeanInterfaceNamePrefixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanInterfaceNamePrefix, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanInterfaceNameSuffix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanInterfaceNameSuffix + * @since 2.6.2 + */ + public String getSimpleBeanInterfaceNameSuffixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanInterfaceNameSuffix, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanDefaultsSuperClass} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanDefaultsSuperClass + * @since 2.7.2 + */ + public String getSimpleBeanDefaultsSuperClassTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanDefaultsSuperClass, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanDefaultsClassNamePrefix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanDefaultsClassNamePrefix + * @since 2.7.2 + */ + public String getSimpleBeanDefaultsClassNamePrefixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanDefaultsClassNamePrefix, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanDefaultsClassNameSuffix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * <strong>If not filled, then use default {@code s} value.</strong> + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanDefaultsClassNameSuffix + * @since 2.6.2 + */ + public String getSimpleBeanDefaultsClassNameSuffixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + String value = TagValueUtil.findTagValue(Store.simpleBeanDefaultsClassNameSuffix, classifier, aPackage, model); + if (StringUtils.isBlank(value)) { + value = "s"; + } + return value; + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceSuperClass} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceSuperClass + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceSuperClassTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanWithNoInterfaceSuperClass, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceDefaultsSuperClass} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceDefaultsSuperClass + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceDefaultsSuperClassTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanWithNoInterfaceDefaultsSuperClass, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceClassNamePrefix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceClassNamePrefix + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceClassNamePrefixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanWithNoInterfaceClassNamePrefix, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceClassNameSuffix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceClassNameSuffix + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceClassNameSuffixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanWithNoInterfaceClassNameSuffix, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceDefaultsClassNamePrefix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceDefaultsClassNamePrefix + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceDefaultsClassNamePrefixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.simpleBeanWithNoInterfaceDefaultsClassNamePrefix, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#simpleBeanWithNoInterfaceDefaultsClassNameSuffix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * <strong>If not filled, then use default {@code s} value.</strong> + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#simpleBeanWithNoInterfaceDefaultsClassNameSuffix + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceDefaultsClassNameSuffixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + String value = TagValueUtil.findTagValue(Store.simpleBeanWithNoInterfaceDefaultsClassNameSuffix, classifier, aPackage, model); + if (StringUtils.isBlank(value)) { + value = "s"; + } + return value; + } + + /** + * Obtain the value of the {@link Store#java8} tag value on the given model. + * + * @param model model to seek + * @return {@code true} the none empty value of the found tag value or {@code false} if not found nor empty. + * @see Store#java8 + * @since 2.15 + */ + public boolean isUseJava8(ObjectModel model) { + return TagValueUtil.findBooleanTagValue(Store.java8, model); + } + +} diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaEnumerationTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaEnumerationTransformer.java index a7f73fe..07880d1 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaEnumerationTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaEnumerationTransformer.java @@ -27,7 +27,7 @@ package org.nuiton.eugene.java; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.nuiton.eugene.EugeneStereoTypes; +import org.nuiton.eugene.EugeneCoreStereotypes; import org.nuiton.eugene.models.object.ObjectModelEnumeration; import org.nuiton.eugene.models.object.ObjectModelPackage; @@ -72,7 +72,7 @@ public class JavaEnumerationTransformer extends ObjectModelTransformerToJava { protected boolean canGenerate(ObjectModelEnumeration input) { ObjectModelPackage aPackage = getPackage(input); - boolean b = !EugeneStereoTypes.hasSkipStereotype(input, aPackage); + boolean b = !EugeneCoreStereotypes.hasSkipStereotype(input, aPackage); if (b) { // check if not found in class-path diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesStereoTypes.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesStereoTypes.java index c4402e8..7344287 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesStereoTypes.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesStereoTypes.java @@ -204,7 +204,7 @@ public class JavaTemplatesStereoTypes extends StereotypeDefinitionProvider { target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, documentation = "To generate or not constructors predicates on propertyes on beans.\n" + "(only effective with simple bean with no interface generator)") - public static final String STEREOTYPE_SIMPLE_BEAN_WITH_NO_INTERFACE_SKIP_GENERATE_DEFAULT_CONSTRUCTORS= "simpleBeanWithNoInterfaceGenerateConstructors"; + public static final String STEREOTYPE_SIMPLE_BEAN_WITH_NO_INTERFACE_SKIP_GENERATE_DEFAULT_CONSTRUCTORS= "simpleBeanWithNoInterfaceSkipGenerateConstructors"; /** * Check if the given classifier has the {@link #STEREOTYPE_BEAN} stereotype. diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java index b3ce62f..705218c 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java @@ -88,8 +88,8 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr ImmutableSet.Builder<ObjectModelClass> beanClassesBuilder = new ImmutableSet.Builder<>(); ImmutableSet.Builder<ObjectModelClass> beanDefaultClassesBuilder = new ImmutableSet.Builder<>(); - JavaTemplatesTagValues javaTemplatesTagValues = getJavaTemplatesTagValues(); - JavaTemplatesStereoTypes javaTemplatesStereoTypes = getJavaTemplatesStereoTypes(); + EugeneJavaTagValues javaTemplatesTagValues = getJavaTemplatesTagValues(); + EugeneJavaStereoTypes javaTemplatesStereoTypes = getJavaTemplatesStereoTypes(); for (ObjectModelClass aClass : model.getClasses()) { diff --git a/eugene-java-templates/src/main/resources/META-INF/services/org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider b/eugene-java-templates/src/main/resources/META-INF/services/org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider new file mode 100644 index 0000000..a0b948a --- /dev/null +++ b/eugene-java-templates/src/main/resources/META-INF/services/org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider @@ -0,0 +1 @@ +org.nuiton.eugene.java.EugeneJavaStereoTypes \ No newline at end of file diff --git a/eugene-java-templates/src/main/resources/META-INF/services/org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider b/eugene-java-templates/src/main/resources/META-INF/services/org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider new file mode 100644 index 0000000..982aa83 --- /dev/null +++ b/eugene-java-templates/src/main/resources/META-INF/services/org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider @@ -0,0 +1 @@ +org.nuiton.eugene.java.EugeneJavaTagValues \ No newline at end of file diff --git a/eugene-java-templates/src/test/java/org/nuiton/eugene/java/EugeneJavaStereoTypesTest.java b/eugene-java-templates/src/test/java/org/nuiton/eugene/java/EugeneJavaStereoTypesTest.java new file mode 100644 index 0000000..1ebd33b --- /dev/null +++ b/eugene-java-templates/src/test/java/org/nuiton/eugene/java/EugeneJavaStereoTypesTest.java @@ -0,0 +1,80 @@ +package org.nuiton.eugene.java; + +/* + * #%L + * EUGene :: Java templates + * %% + * Copyright (C) 2012 - 2014 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.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.nuiton.eugene.models.extension.stereotype.MismatchStereotypeTargetException; +import org.nuiton.eugene.models.extension.stereotype.StereotypeNotFoundException; +import org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider; +import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelEnumeration; +import org.nuiton.eugene.models.object.ObjectModelInterface; +import org.nuiton.eugene.models.object.ObjectModelOperation; +import org.nuiton.eugene.models.object.ObjectModelPackage; + +public class EugeneJavaStereoTypesTest { + + protected StereotypeMetadatasProvider provider; + + @Before + public void setUp() throws Exception { + provider = new EugeneJavaStereoTypes(); + } + + @Test + public void validate() throws Exception { + + validate(EugeneJavaStereoTypes.Store.bean.getName(), true, ObjectModelPackage.class, ObjectModelClassifier.class, ObjectModelClass.class, ObjectModelEnumeration.class, ObjectModelInterface.class); + validate(EugeneJavaStereoTypes.Store.generateNotEmptyCollections.getName(), true, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class, ObjectModelClass.class, ObjectModelEnumeration.class); + validate(EugeneJavaStereoTypes.Store.generatePropertyChangeSupport.getName(), true, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class, ObjectModelClass.class, ObjectModelEnumeration.class); + validate(EugeneJavaStereoTypes.Store.generateNotEmptyCollections.getName(), false, ObjectModelOperation.class, ObjectModelAttribute.class); + validate(EugeneJavaStereoTypes.Store.generatePropertyChangeSupport.getName(), false, ObjectModelOperation.class, ObjectModelAttribute.class); + + validate(EugeneJavaStereoTypes.Store.bean.getName(), false, ObjectModel.class, ObjectModelOperation.class); + + long l = System.nanoTime(); + validate(EugeneJavaStereoTypes.Store.bean.getName() + l, false, ObjectModelPackage.class, ObjectModel.class, ObjectModelOperation.class); + validate(EugeneJavaStereoTypes.Store.generateNotEmptyCollections.getName() + l, false, ObjectModelPackage.class, ObjectModelOperation.class, ObjectModelAttribute.class); + validate(EugeneJavaStereoTypes.Store.generatePropertyChangeSupport.getName() + l, false, ObjectModelPackage.class, ObjectModelOperation.class, ObjectModelAttribute.class); + + } + + protected void validate(String name, boolean expected, Class<?>... types) { + for (Class<?> type : types) { + try { + provider.validate(name, type); + Assert.assertTrue(expected); + } catch (StereotypeNotFoundException e) { + Assert.assertFalse(expected); + } catch (MismatchStereotypeTargetException e) { + Assert.assertFalse(expected); + } + } + } + +} diff --git a/eugene-java-templates/src/test/java/org/nuiton/eugene/java/EugeneJavaTagValuesTest.java b/eugene-java-templates/src/test/java/org/nuiton/eugene/java/EugeneJavaTagValuesTest.java new file mode 100644 index 0000000..6dd1643 --- /dev/null +++ b/eugene-java-templates/src/test/java/org/nuiton/eugene/java/EugeneJavaTagValuesTest.java @@ -0,0 +1,71 @@ +package org.nuiton.eugene.java; + +/* + * #%L + * EUGene :: Java templates + * %% + * Copyright (C) 2012 - 2014 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.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.nuiton.eugene.models.extension.tagvalue.MismatchTagValueTargetException; +import org.nuiton.eugene.models.extension.tagvalue.TagValueNotFoundException; +import org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider; +import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelEnumeration; +import org.nuiton.eugene.models.object.ObjectModelOperation; +import org.nuiton.eugene.models.object.ObjectModelPackage; + +public class EugeneJavaTagValuesTest { + + protected TagValueMetadatasProvider provider; + + @Before + public void setUp() throws Exception { + provider = new EugeneJavaTagValues(); + } + + @Test + public void validate() throws Exception { + validate(EugeneJavaTagValues.Store.beanSuperClass.getName(), true, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class, ObjectModelClass.class, ObjectModelEnumeration.class); + validate(EugeneJavaTagValues.Store.beanSuperClass.getName(), false, ObjectModelOperation.class, ObjectModelAttribute.class); + + long l = System.nanoTime(); + validate(EugeneJavaTagValues.Store.beanSuperClass.getName() + l, false, ObjectModelPackage.class, ObjectModelOperation.class, ObjectModelAttribute.class); + } + + + protected void validate(String name, boolean expected, Class<?>... types) { + for (Class<?> type : types) { + try { + provider.validate(name, type); + Assert.assertTrue(expected); + } catch (TagValueNotFoundException e) { + Assert.assertFalse(expected); + } catch (MismatchTagValueTargetException e) { + Assert.assertFalse(expected); + } + } + } + +} diff --git a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/GenerateMojo.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/GenerateMojo.java index a76908c..0172e55 100644 --- a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/GenerateMojo.java +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/GenerateMojo.java @@ -38,15 +38,13 @@ import org.nuiton.eugene.ModelHelper; import org.nuiton.eugene.ModelReader; import org.nuiton.eugene.Template; import org.nuiton.eugene.models.Model; +import org.nuiton.eugene.models.extension.stereotype.StereotypeMetadatasProviderManagerExtension; +import org.nuiton.eugene.models.extension.stereotype.provider.AggregateStereotypeMetadatasProvider; +import org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadatasProviderManagerExtension; +import org.nuiton.eugene.models.extension.tagvalue.provider.AggregateTagValueMetadatasProvider; +import org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider; import org.nuiton.eugene.models.object.reader.InvalidModelPropertiesException; -import org.nuiton.eugene.models.stereotype.AggregateStereotypeDefinitionProvider; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProvider; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProviderManagerExtension; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProviders; -import org.nuiton.eugene.models.tagvalue.AggregateTagValueDefinitionProvider; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProvider; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProviderManagerExtension; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProviders; import org.nuiton.eugene.plugin.writer.BaseChainedFileWriter; import org.nuiton.eugene.plugin.writer.BaseChainedFileWriterToMemoryModel; import org.nuiton.eugene.plugin.writer.XmiChainedFileWriter; @@ -336,22 +334,38 @@ public class GenerateMojo extends AbstractPlugin implements ChainedFileWriterCon /** All available templates introspects via plexus. */ @Component(role = Template.class) protected Map<String, Template<?>> modelTemplates; +// +// /** +// * All available stereotype providers introspects via plexus. +// * +// * @since 2.9 +// */ +// @Component(role = StereotypeMetadatasProvider.class) +// protected Map<String, StereotypeMetadatasProvider> stereotypeMetadatasProviders; +// +// /** +// * All available tag value providers introspects via plexus. +// * +// * @since 2.9 +// */ +// @Component(role = TagValueMetadatasProvider.class) +// protected Map<String, TagValueMetadatasProvider> tagValueMetadatasProviders; /** * All available stereotype providers introspects via plexus. * - * @since 2.9 + * @since 3.0 */ - @Component(role = StereotypeDefinitionProvider.class) - protected Map<String, StereotypeDefinitionProvider> stereotypeDefinitionProviders; + @Component(role = StereotypeMetadatasProvider.class) + protected Set<StereotypeMetadatasProvider> stereotypeMetadatasProviders; /** * All available tag value providers introspects via plexus. * - * @since 2.9 + * @since 3.0 */ - @Component(role = TagValueDefinitionProvider.class) - protected Map<String, TagValueDefinitionProvider> tagValueDefinitionProviders; + @Component(role = TagValueMetadatasProvider.class) + protected Set<TagValueMetadatasProvider> tagValueMetadatasProviders; /** The engine to compute {@link ChainedFileWriter} from inputs entries. */ @Component(role = ChainedWriterEngine.class) @@ -471,10 +485,10 @@ public class GenerateMojo extends AbstractPlugin implements ChainedFileWriterCon // add model writer support properties.put(BaseChainedFileWriterToMemoryModel.PROP_TAG_VALUE_DEFINITION_PROVIDER, - getTagValueDefinitionProvider()); + getTagValueMetadatasProvider()); properties.put(BaseChainedFileWriterToMemoryModel.PROP_STEREOTYPE_DEFINITION_PROVIDER, - getStereotypeDefinitionProvider()); + getStereotypeMetadatasProvider()); properties.put(BaseChainedFileWriterToMemoryModel.PROP_FAIL_IF_UNSAFE, failIfUnsafe); @@ -578,19 +592,19 @@ public class GenerateMojo extends AbstractPlugin implements ChainedFileWriterCon getLog().info("Process phase [generator]"); - AggregateTagValueDefinitionProvider tagValueDefinitionProvider = getTagValueDefinitionProvider(); - AggregateStereotypeDefinitionProvider stereotypeDefinitionProvider = getStereotypeDefinitionProvider(); + AggregateTagValueMetadatasProvider tagValueMetadatasProvider = getTagValueMetadatasProvider(); + AggregateStereotypeMetadatasProvider stereotypeMetadatasProvider = getStereotypeMetadatasProvider(); for (ChainedFileWriterToMemoryModel entry : models) { Model model = entry.getModel(); // init tag values extension - TagValueDefinitionProviderManagerExtension extension = model.getExtension(TagValueDefinitionProviderManagerExtension.OBJECTMODEL_EXTENSION, TagValueDefinitionProviderManagerExtension.class); - extension.setAggregateTagValueDefinitionProvider(tagValueDefinitionProvider); + TagValueMetadatasProviderManagerExtension extension = model.getExtension(TagValueMetadatasProviderManagerExtension.OBJECTMODEL_EXTENSION, TagValueMetadatasProviderManagerExtension.class); + extension.setProdiver(tagValueMetadatasProvider); // init stereotype extension - StereotypeDefinitionProviderManagerExtension stereotypeExtension = model.getExtension(StereotypeDefinitionProviderManagerExtension.OBJECTMODEL_EXTENSION, StereotypeDefinitionProviderManagerExtension.class); - stereotypeExtension.setAggregateStereotypeDefinitionProvider(stereotypeDefinitionProvider); + StereotypeMetadatasProviderManagerExtension stereotypeExtension = model.getExtension(StereotypeMetadatasProviderManagerExtension.OBJECTMODEL_EXTENSION, StereotypeMetadatasProviderManagerExtension.class); + stereotypeExtension.setProdiver(stereotypeMetadatasProvider); Long lastModified = entry.getLastModifiedSource(); File outputDir = entry.getOutputDirectory(); @@ -953,51 +967,39 @@ public class GenerateMojo extends AbstractPlugin implements ChainedFileWriterCon } } - protected AggregateTagValueDefinitionProvider getTagValueDefinitionProvider() throws MojoExecutionException { + protected AggregateTagValueMetadatasProvider getTagValueMetadatasProvider() throws MojoExecutionException { - AggregateTagValueDefinitionProvider provider; + AggregateTagValueMetadatasProvider provider; - if (tagValueDefinitionProviders == null || - tagValueDefinitionProviders.isEmpty() || + if (tagValueMetadatasProviders == null || + tagValueMetadatasProviders.isEmpty() || isTestPhase()) { // could not find any model properties via plexus // try to obtain them by ServiceLoader - provider = TagValueDefinitionProviders.newProvider( - getFixedClassLoader(), - verbose - ); + provider = new AggregateTagValueMetadatasProvider(getFixedClassLoader()); } else { - provider = TagValueDefinitionProviders.newProvider( - tagValueDefinitionProviders.values(), - verbose - ); + provider = new AggregateTagValueMetadatasProvider(tagValueMetadatasProviders); } return provider; } - protected AggregateStereotypeDefinitionProvider getStereotypeDefinitionProvider() throws MojoExecutionException { + protected AggregateStereotypeMetadatasProvider getStereotypeMetadatasProvider() throws MojoExecutionException { - AggregateStereotypeDefinitionProvider provider; + AggregateStereotypeMetadatasProvider provider; - if (stereotypeDefinitionProviders == null || - stereotypeDefinitionProviders.isEmpty() || + if (stereotypeMetadatasProviders == null || + stereotypeMetadatasProviders.isEmpty() || isTestPhase()) { // could not find any model properties via plexus // try to obtain them by ServiceLoader - provider = StereotypeDefinitionProviders.newProvider( - getFixedClassLoader(), - verbose - ); + provider = new AggregateStereotypeMetadatasProvider(getFixedClassLoader()); } else { - provider = StereotypeDefinitionProviders.newProvider( - stereotypeDefinitionProviders.values(), - verbose - ); + provider = new AggregateStereotypeMetadatasProvider(stereotypeMetadatasProviders); } return provider; } diff --git a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/modelextension/ElementBean.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/modelextension/ElementBean.java index 1cb6527..8774075 100644 --- a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/modelextension/ElementBean.java +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/modelextension/ElementBean.java @@ -22,7 +22,7 @@ package org.nuiton.eugene.plugin.modelextension; * #L% */ -import org.nuiton.eugene.models.stereotype.StereotypeAble; +import org.nuiton.eugene.models.extension.stereotype.WithStereotypes; import org.nuiton.eugene.models.tagvalue.TagValueAble; import java.util.Map; @@ -64,7 +64,7 @@ public class ElementBean implements Comparable<ElementBean> { return name.compareTo(o.name); } - public <T extends TagValueAble & StereotypeAble> void load(T tag) { + public <T extends TagValueAble & WithStereotypes> void load(T tag) { this.tagValues.putAll(tag.getTagValues()); this.stereotypes.addAll(tag.getStereotypes()); } diff --git a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/modelextension/ModelBeanBuilder.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/modelextension/ModelBeanBuilder.java index b6bf10b..3162419 100644 --- a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/modelextension/ModelBeanBuilder.java +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/modelextension/ModelBeanBuilder.java @@ -22,11 +22,11 @@ package org.nuiton.eugene.plugin.modelextension; * #L% */ +import org.nuiton.eugene.models.extension.stereotype.InvalidStereotypeSyntaxException; +import org.nuiton.eugene.models.extension.tagvalue.InvalidTagValueSyntaxException; 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.tagvalue.InvalidTagValueSyntaxException; import java.io.File; import java.io.IOException; diff --git a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/writer/BaseChainedFileWriterToMemoryModel.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/writer/BaseChainedFileWriterToMemoryModel.java index b714592..897c546 100644 --- a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/writer/BaseChainedFileWriterToMemoryModel.java +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/writer/BaseChainedFileWriterToMemoryModel.java @@ -24,12 +24,12 @@ package org.nuiton.eugene.plugin.writer; import org.nuiton.eugene.ModelReader; import org.nuiton.eugene.models.Model; +import org.nuiton.eugene.models.extension.stereotype.InvalidStereotypeSyntaxException; +import org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider; +import org.nuiton.eugene.models.extension.tagvalue.InvalidTagValueSyntaxException; +import org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider; import org.nuiton.eugene.models.object.ObjectModel; import org.nuiton.eugene.models.object.reader.extension.LoadModelExtension; -import org.nuiton.eugene.models.stereotype.InvalidStereotypeSyntaxException; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProvider; -import org.nuiton.eugene.models.tagvalue.InvalidTagValueSyntaxException; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProvider; import org.nuiton.eugene.writer.ChainedFileWriterConfiguration; import org.nuiton.eugene.writer.ChainedFileWriterToMemoryModel; @@ -51,9 +51,9 @@ public abstract class BaseChainedFileWriterToMemoryModel extends BaseChainedFile public static final String PROP_MODEL_READER = "modelReader"; - public static final String PROP_TAG_VALUE_DEFINITION_PROVIDER = "tagValueDefinitionProvider"; + public static final String PROP_TAG_VALUE_DEFINITION_PROVIDER = "tagValueMetadatasProvider"; - public static final String PROP_STEREOTYPE_DEFINITION_PROVIDER = "stereotypeDefinitionProvider"; + public static final String PROP_STEREOTYPE_DEFINITION_PROVIDER = "stereotypeMetadatasProvider"; public static final String PROP_FAIL_IF_UNSAFE = "failIfUnsafe"; @@ -72,8 +72,8 @@ public abstract class BaseChainedFileWriterToMemoryModel extends BaseChainedFile super( PROP_READER, "reader", PROP_MODEL_READER, "xmlModelReader", - PROP_TAG_VALUE_DEFINITION_PROVIDER, "tagValueDefinitionProvider", - PROP_STEREOTYPE_DEFINITION_PROVIDER, "stereotypeDefinitionProvider", + PROP_TAG_VALUE_DEFINITION_PROVIDER, "tagValueMetadatasProvider", + PROP_STEREOTYPE_DEFINITION_PROVIDER, "stereotypeMetadatasProvider", PROP_MODEL_PROPERTIES_PROVIDER, "modelPropertiesProvider", PROP_FAIL_IF_UNSAFE, "failIfUnsafe" ); @@ -117,12 +117,12 @@ public abstract class BaseChainedFileWriterToMemoryModel extends BaseChainedFile return getProperty(PROP_READER, String.class); } - protected TagValueDefinitionProvider getTagValueDefinitionProvider() { - return getProperty(PROP_TAG_VALUE_DEFINITION_PROVIDER, TagValueDefinitionProvider.class); + protected TagValueMetadatasProvider getTagValueDefinitionProvider() { + return getProperty(PROP_TAG_VALUE_DEFINITION_PROVIDER, TagValueMetadatasProvider.class); } - protected StereotypeDefinitionProvider getStereotypeDefinitionProvider() { - return getProperty(PROP_STEREOTYPE_DEFINITION_PROVIDER, StereotypeDefinitionProvider.class); + protected StereotypeMetadatasProvider getStereotypeDefinitionProvider() { + return getProperty(PROP_STEREOTYPE_DEFINITION_PROVIDER, StereotypeMetadatasProvider.class); } protected boolean isFailIfUnsafe() { @@ -181,8 +181,8 @@ public abstract class BaseChainedFileWriterToMemoryModel extends BaseChainedFile boolean verbose = configuration.isVerbose(); - getModelReader().setStereotypeDefinitionProvider(getStereotypeDefinitionProvider()); - getModelReader().setTagValueDefinitionProvider(getTagValueDefinitionProvider()); + getModelReader().setStereotypeMetadatasProvider(getStereotypeDefinitionProvider()); + getModelReader().setTagValueMetadatasProvider(getTagValueDefinitionProvider()); // set the verbose level of the model reader getModelReader().setVerbose(verbose); diff --git a/eugene/src/main/java/org/nuiton/eugene/EugeneCoreStereotypes.java b/eugene/src/main/java/org/nuiton/eugene/EugeneCoreStereotypes.java new file mode 100644 index 0000000..b864d7d --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/EugeneCoreStereotypes.java @@ -0,0 +1,133 @@ +package org.nuiton.eugene; + +import com.google.common.collect.ImmutableSet; +import org.nuiton.eugene.models.extension.stereotype.StereotypeMetadata; +import org.nuiton.eugene.models.extension.stereotype.StereotypeUtil; +import org.nuiton.eugene.models.extension.stereotype.provider.DefaultStereotypeMetadatasProvider; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelPackage; + +import java.util.Set; + +import static org.nuiton.i18n.I18n.n; + +/** + * Defines all stereotypes managed by Eugene. + * + * In another library using eugene, please extends this contract to put your + * own stereotypes, to get a unique place where to find stereotypes. + * + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @plexus.component role="org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider" role-hint="eugene" + * @since 3.0 + */ +public class EugeneCoreStereotypes extends DefaultStereotypeMetadatasProvider { + + public enum Store implements StereotypeMetadata { + /** + * Stereotype to mark an attribute with multiplicity as ordered. + * + * It means that order of insertion is maintained: in Java, it will lead + * to a collection typed with {@link java.util.List} or {@link java.util.LinkedHashSet} + * or {@link java.util.LinkedHashMap}. + * + * @since 2.8 + */ + ordered(n("eugene.core.stereotypes.ordered"), ObjectModelAttribute.class), + /** + * Stereotype to mark an attribute with multiplicity as unique. + * + * It means that uniqueness of elements is maintained in the collection: in Java, it + * will lead to a collection typed with {@link java.util.Set}. + */ + unique(n("eugene.core.stereotypes.unique"), ObjectModelAttribute.class), + /** + * Stereotype to skip generation for some transformer. + */ + skip(n("eugene.core.stereotypes.skip"), ObjectModelClassifier.class, ObjectModelPackage.class); + + private final Set<Class<?>> targets; + private final String i18nDocumentationKey; + + Store(String i18nDocumentationKey, Class<?>... targets) { + this.targets = ImmutableSet.copyOf(targets); + this.i18nDocumentationKey = i18nDocumentationKey; + } + + @Override + public String getName() { + return name(); + } + + @Override + public Set<Class<?>> getTargets() { + return targets; + } + + @Override + public String getI18nDocumentationKey() { + return i18nDocumentationKey; + } + + @Override + public boolean isDeprecated() { + return false; + } + + } + + public EugeneCoreStereotypes() { + super((StereotypeMetadata[]) Store.values()); + } + + /** + * Check if the given attribute has the {@link Store#ordered} stereotype. + * + * @param attribute attribute to test + * @return {@code true} if stereotype was found, {@code false otherwise} + * @see Store#ordered + * @since 2.9 + */ + public static boolean hasOrderedStereotype(ObjectModelAttribute attribute) { + return StereotypeUtil.findDirectStereotype(Store.ordered, attribute); + } + + /** + * Check if the given attribute has the {@link Store#unique} stereotype. + * + * @param attribute attribute to test + * @return {@code true} if stereotype was found, {@code false otherwise} + * @see Store#unique + * @since 2.9 + */ + public static boolean hasUniqueStereotype(ObjectModelAttribute attribute) { + return StereotypeUtil.findDirectStereotype(Store.unique, attribute); + } + + /** + * Check if the given classifier has the {@link Store#skip} stereotype. + * + * @param classifier classifier to test + * @param aPackage package to test + * @return {@code true} if stereotype was found, {@code false otherwise} + * @see Store#skip + * @since 2.9 + */ + public static boolean hasSkipStereotype(ObjectModelClassifier classifier, ObjectModelPackage aPackage) { + return StereotypeUtil.findDirectStereotype(Store.skip, classifier, aPackage); + } + + /** + * Check if the given package has the {@link Store#skip} stereotype. + * + * @param aPackage package to test + * @return {@code true} if stereotype was found, {@code false otherwise} + * @see Store#skip + */ + public static boolean hasSkipStereotype(ObjectModelPackage aPackage) { + return StereotypeUtil.findDirectStereotype(Store.skip, aPackage); + } +} diff --git a/eugene/src/main/java/org/nuiton/eugene/EugeneCoreTagValues.java b/eugene/src/main/java/org/nuiton/eugene/EugeneCoreTagValues.java new file mode 100644 index 0000000..9145702 --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/EugeneCoreTagValues.java @@ -0,0 +1,236 @@ +package org.nuiton.eugene; + +import com.google.common.collect.ImmutableSet; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; +import org.nuiton.eugene.models.extension.tagvalue.TagValueUtil; +import org.nuiton.eugene.models.extension.tagvalue.matcher.EqualsTagValueNameMatcher; +import org.nuiton.eugene.models.extension.tagvalue.provider.DefaultTagValueMetadatasProvider; +import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelElement; +import org.nuiton.eugene.models.object.ObjectModelPackage; + +import java.util.Set; + +import static org.nuiton.i18n.I18n.n; + +/** + * Created on 24/09/16. + * + * Defines all tag values managed by Eugene. + * + * In another library using eugene, please extends this contract to put your + * own tag values, to get a unique place where to find tag values. + * + * @author Tony Chemit - chemit@codelutin.com + * @plexus.component role="org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider" role-hint="eugene" + * @since 3.0 + */ +public class EugeneCoreTagValues extends DefaultTagValueMetadatasProvider { + + public enum Store implements TagValueMetadata { + + /** + * Tag value to add the version of the model from outside (says in the + * properties file associated to the model).. + * + * Actually, the eugene api does not use to modify the model. ItaTa is only + * used while reading the properties associated with a model and if found is + * directly set to the {@code version} field of the model. + * + * @since 2.3 + */ + version(n("eugene.core.tagValues.version"), String.class, null, ObjectModel.class), + + /** + * Tag value to add on constants enumeration (or other incoming dev) + * a prefix to constant to generate. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @since 2.5 + */ + documentation(n("eugene.core.tagValues.documentation"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelElement.class), + + /** + * Tag value to add on constants enumeration (or other incoming dev) + * a prefix to constant to generate. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @since 2.3 + */ + constantPrefix(n("eugene.core.tagValues.constantPrefix"), String.class, "PROPERTY_", ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * Tag value to specify the i18n prefix to use whene generating i18n keys. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @since 2.3 + */ + i18n(n("eugene.core.tagValues.i18n"), String.class, null, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * Tag value to generate also {@code getXXX} methods for a boolean property. + * + * @since 2.12 + */ + generateBooleanGetMethods(n("eugene.core.tagValues.generateBooleanGetMethods"), boolean.class, "false", ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class), + + /** + * To add a generic to an attribute. + * + * @since 3.0 + */ + attributeGeneric(n("eugene.core.tagValues.attributeGeneric"), String.class, null, ObjectModelAttribute.class); + + private final Set<Class<?>> targets; + private final Class<?> type; + private final String i18nDocumentationKey; + private final String defaultValue; + + Store(String i18nDocumentationKey, Class<?> type, String defaultValue, Class<?>... targets) { + this.targets = ImmutableSet.copyOf(targets); + this.type = type; + this.i18nDocumentationKey = i18nDocumentationKey; + this.defaultValue = defaultValue; + } + + @Override + public String getName() { + return name(); + } + + @Override + public Set<Class<?>> getTargets() { + return targets; + } + + @Override + public Class<?> getType() { + return type; + } + + @Override + public Class<EqualsTagValueNameMatcher> getMatcherClass() { + return EqualsTagValueNameMatcher.class; + } + + @Override + public String getI18nDocumentationKey() { + return i18nDocumentationKey; + } + + @Override + public String getDefaultValue() { + return defaultValue; + } + + @Override + public boolean isDeprecated() { + return false; + } + + } + + public EugeneCoreTagValues() { + super((TagValueMetadata[]) Store.values()); + } + + /** + * Obtain the value of the {@link Store#documentation} tag value on the given model. + * + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#documentation + * @since 2.3 + */ + public String getDocumentationTagValue(ObjectModel model) { + return TagValueUtil.findTagValue(Store.documentation, model); + } + + /** + * Obtain the value of the {@link Store#documentation} tag value on the given element. + * + * @param element element to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#documentation + * @since 2.3 + */ + public String getDocumentationTagValue(ObjectModelElement element) { + return TagValueUtil.findTagValue(Store.documentation, element); + } + + /** + * Obtain the value of the {@link Store#documentation} tag value on the given package. + * + * @param aPackage package to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#documentation + * @since 2.12 + */ + public String getDocumentationTagValue(ObjectModelPackage aPackage) { + return TagValueUtil.findTagValue(Store.documentation, aPackage); + } + + /** + * Cherche et renvoie le prefixe i18n à utiliser sur cet element, sinon sur + * le model. + * + * @param element l'élément à tester + * @param aPackage package to seek + * @param model le modele utilisé + * @return le prefix i18n ou <code>null</code> si non spécifié + * @since 2.3 + */ + public String getI18nPrefixTagValue(ObjectModelElement element, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.i18n, element, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#generateBooleanGetMethods} + * tag value on the given model, package or classifier. + * + * It will first look on the model, then on package and then in the given classifier. + * + * @param classifier classifier to seek + * @param aPackage package to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#generateBooleanGetMethods + * @since 2.12 + */ + public boolean isGenerateBooleanGetMethods(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findBooleanTagValue(Store.generateBooleanGetMethods, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#constantPrefix} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @param classifier classifier to seek + * @param aPackage package to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#constantPrefix + * @since 2.3 + */ + public String getConstantPrefixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + return TagValueUtil.findTagValue(Store.constantPrefix, classifier, aPackage, model); + } + + /** + * Obtain the value of the {@link Store#attributeGeneric} tag value on the given attribute. + * + * @param attribute attribute to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see Store#attributeGeneric + * @since 3.0 + */ + public String getAttributeGenericTagValue(ObjectModelAttribute attribute) { + return TagValueUtil.findTagValue(Store.attributeGeneric, attribute); + } +} diff --git a/eugene/src/main/java/org/nuiton/eugene/EugeneStereoTypes.java b/eugene/src/main/java/org/nuiton/eugene/EugeneStereoTypes.java index 2a124e3..401d25e 100644 --- a/eugene/src/main/java/org/nuiton/eugene/EugeneStereoTypes.java +++ b/eugene/src/main/java/org/nuiton/eugene/EugeneStereoTypes.java @@ -38,6 +38,7 @@ import org.nuiton.eugene.models.stereotype.Stereotypes; * @plexus.component role="org.nuiton.eugene.models.stereotype.StereotypeDefinitionProvider" role-hint="eugene" * @since 2.9 */ +@Deprecated public class EugeneStereoTypes extends StereotypeDefinitionProvider { /** diff --git a/eugene/src/main/java/org/nuiton/eugene/EugeneTagValues.java b/eugene/src/main/java/org/nuiton/eugene/EugeneTagValues.java index 62ce261..beec633 100644 --- a/eugene/src/main/java/org/nuiton/eugene/EugeneTagValues.java +++ b/eugene/src/main/java/org/nuiton/eugene/EugeneTagValues.java @@ -39,6 +39,7 @@ import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProvider; * @plexus.component role="org.nuiton.eugene.models.tagvalue.TagValueDefinitionProvider" role-hint="eugene" * @since 2.3 */ +@Deprecated public class EugeneTagValues extends TagValueDefinitionProvider { /** diff --git a/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java b/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java index 06c58cb..0fe6f0d 100644 --- a/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java +++ b/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java @@ -59,11 +59,7 @@ public class GeneratorUtil { * Static singleton instance used to read defaultValue * TODO-tchemit 2014-06-19 Remove this when remove deprecated methods using it */ - protected final static EugeneTagValues EUGENE_TAG_VALUES = new EugeneTagValues(); - - static { - EUGENE_TAG_VALUES.init(); - } + protected final static EugeneCoreTagValues EUGENE_CORE_TAG_VALUES = new EugeneCoreTagValues(); /** * return parent package of given package (return given package if it is a root package) diff --git a/eugene/src/main/java/org/nuiton/eugene/ModelReader.java b/eugene/src/main/java/org/nuiton/eugene/ModelReader.java index 77f8c8f..827f9ae 100644 --- a/eugene/src/main/java/org/nuiton/eugene/ModelReader.java +++ b/eugene/src/main/java/org/nuiton/eugene/ModelReader.java @@ -23,8 +23,8 @@ package org.nuiton.eugene; import org.nuiton.eugene.models.Model; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProvider; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProvider; +import org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider; +import org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider; import java.io.File; import java.io.IOException; @@ -60,14 +60,14 @@ public abstract class ModelReader<M extends Model> { * * @since 2.9 */ - protected TagValueDefinitionProvider tagValueDefinitionProvider; + protected TagValueMetadatasProvider tagValueMetadatasProvider; /** * Provider of stereotypes. * * @since 2.9 */ - protected StereotypeDefinitionProvider stereotypeDefinitionProvider; + protected StereotypeMetadatasProvider stereotypeMetadatasProvider; /** * Gets the type of model. @@ -111,31 +111,31 @@ public abstract class ModelReader<M extends Model> { */ public abstract M read(File... file) throws IOException; - public TagValueDefinitionProvider getTagValueDefinitionProvider() { - return tagValueDefinitionProvider; + public TagValueMetadatasProvider getTagValueMetadatasProvider() { + return tagValueMetadatasProvider; } /** * Sets the provider of available tag values. * - * @param tagValueDefinitionProvider the provider to use + * @param tagValueMetadatasProvider the provider to use * @since 2.9 */ - public void setTagValueDefinitionProvider(TagValueDefinitionProvider tagValueDefinitionProvider) { - this.tagValueDefinitionProvider = tagValueDefinitionProvider; + public void setTagValueMetadatasProvider(TagValueMetadatasProvider tagValueMetadatasProvider) { + this.tagValueMetadatasProvider = tagValueMetadatasProvider; } - public StereotypeDefinitionProvider getStereotypeDefinitionProvider() { - return stereotypeDefinitionProvider; + public StereotypeMetadatasProvider getStereotypeMetadatasProvider() { + return stereotypeMetadatasProvider; } /** * Sets the provider of available stereotypes. * - * @param stereotypeDefinitionProvider the provider to use + * @param stereotypeMetadatasProvider the provider to use * @since 2.9 */ - public void setStereotypeDefinitionProvider(StereotypeDefinitionProvider stereotypeDefinitionProvider) { - this.stereotypeDefinitionProvider = stereotypeDefinitionProvider; + public void setStereotypeMetadatasProvider(StereotypeMetadatasProvider stereotypeMetadatasProvider) { + this.stereotypeMetadatasProvider = stereotypeMetadatasProvider; } } diff --git a/eugene/src/main/java/org/nuiton/eugene/java/JavaGeneratorUtil.java b/eugene/src/main/java/org/nuiton/eugene/java/JavaGeneratorUtil.java index 0561632..255371d 100644 --- a/eugene/src/main/java/org/nuiton/eugene/java/JavaGeneratorUtil.java +++ b/eugene/src/main/java/org/nuiton/eugene/java/JavaGeneratorUtil.java @@ -22,7 +22,7 @@ package org.nuiton.eugene.java; import org.apache.commons.lang3.StringUtils; -import org.nuiton.eugene.EugeneStereoTypes; +import org.nuiton.eugene.EugeneCoreStereotypes; import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.models.object.ObjectModelAttribute; import org.nuiton.eugene.models.object.ObjectModelClass; @@ -351,13 +351,13 @@ public class JavaGeneratorUtil extends GeneratorUtil { } public static boolean isOrdered(ObjectModelAttribute attr) { - return attr.isOrdered() || EugeneStereoTypes.hasOrderedStereotype(attr); + return attr.isOrdered() || EugeneCoreStereotypes.hasOrderedStereotype(attr); } public static Class<?> getCollectionType(ObjectModelAttribute attr) { boolean ordered = isOrdered(attr); - boolean unique = EugeneStereoTypes.hasUniqueStereotype(attr); + boolean unique = EugeneCoreStereotypes.hasUniqueStereotype(attr); // Change type for Multiple attribute Class<?> result; @@ -381,7 +381,7 @@ public class JavaGeneratorUtil extends GeneratorUtil { public static Class<?> getCollectionInstanceType(ObjectModelAttribute attr) { boolean ordered = isOrdered(attr); - boolean unique = EugeneStereoTypes.hasUniqueStereotype(attr); + boolean unique = EugeneCoreStereotypes.hasUniqueStereotype(attr); // Change type for Multiple attribute Class<?> result; diff --git a/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java b/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java index 52072fa..ab57b7d 100644 --- a/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java +++ b/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java @@ -25,11 +25,15 @@ package org.nuiton.eugene.java; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.nuiton.eugene.EugeneTagValues; +import org.nuiton.eugene.EugeneCoreTagValues; import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.Template; import org.nuiton.eugene.java.extension.ImportsManager; import org.nuiton.eugene.java.extension.ObjectModelAnnotation; +import org.nuiton.eugene.models.extension.stereotype.StereotypeMetadatasProviderManagerExtension; +import org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadatasProviderManagerExtension; +import org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider; import org.nuiton.eugene.models.object.ObjectModel; import org.nuiton.eugene.models.object.ObjectModelAttribute; import org.nuiton.eugene.models.object.ObjectModelClass; @@ -45,10 +49,6 @@ import org.nuiton.eugene.models.object.ObjectModelPackage; import org.nuiton.eugene.models.object.ObjectModelParameter; import org.nuiton.eugene.models.object.ObjectModelTransformer; import org.nuiton.eugene.models.object.ObjectModelType; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProvider; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProviderManagerExtension; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProvider; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProviderManagerExtension; import org.nuiton.i18n.I18n; import javax.annotation.Generated; @@ -78,11 +78,11 @@ public abstract class ObjectModelTransformerToJava extends ObjectModelTransforme private String constantPrefix; - private EugeneTagValues eugeneTagValues; + private EugeneCoreTagValues eugeneTagValues; - public EugeneTagValues getEugeneTagValues() { + public EugeneCoreTagValues getEugeneTagValues() { if (eugeneTagValues == null) { - eugeneTagValues = getTagValueDefinitionProvider(EugeneTagValues.class); + eugeneTagValues = getTagValueMetadatasProvider(EugeneCoreTagValues.class); } return eugeneTagValues; } @@ -845,7 +845,7 @@ public abstract class ObjectModelTransformerToJava extends ObjectModelTransforme * * If found, add all literals on {@code output} model as constants. * - * You can add a {@link EugeneTagValues#TAG_CONSTANT_PREFIX} to your + * You can add a {@link EugeneCoreTagValues.Store#constantPrefix} to your * enumeration to prefix constant names. * * @param input the input model @@ -916,7 +916,7 @@ public abstract class ObjectModelTransformerToJava extends ObjectModelTransforme /** * Used to initialize constant prefix depends on model tagvalue {@link - * EugeneTagValues#TAG_CONSTANT_PREFIX}. If no tagvalue found, the default + * EugeneCoreTagValues.Store#constantPrefix}. If no tagvalue found, the default * value will be an empty prefix. */ public void initConstantPrefixFromModel() { @@ -1017,18 +1017,18 @@ public abstract class ObjectModelTransformerToJava extends ObjectModelTransforme return isInClassPath(packageName + "." + className); } - protected <T extends TagValueDefinitionProvider> T getTagValueDefinitionProvider(Class<T> providerType) { + protected <T extends TagValueMetadatasProvider> T getTagValueMetadatasProvider(Class<T> providerType) { - TagValueDefinitionProviderManagerExtension extension = model.getExtension( - TagValueDefinitionProviderManagerExtension.OBJECTMODEL_EXTENSION, TagValueDefinitionProviderManagerExtension.class); - return extension.getTagValueDefinitionProvider(providerType); + TagValueMetadatasProviderManagerExtension extension = model.getExtension( + TagValueMetadatasProviderManagerExtension.OBJECTMODEL_EXTENSION, TagValueMetadatasProviderManagerExtension.class); + return extension.getProvider(providerType); } - protected <T extends StereotypeDefinitionProvider> T getStereotypeDefinitionProvider(Class<T> providerType) { + protected <T extends StereotypeMetadatasProvider> T getStereotypeMetadatasProvider(Class<T> providerType) { - StereotypeDefinitionProviderManagerExtension extension = model.getExtension( - StereotypeDefinitionProviderManagerExtension.OBJECTMODEL_EXTENSION, StereotypeDefinitionProviderManagerExtension.class); - return extension.getStereotypeDefinitionProvider(providerType); + StereotypeMetadatasProviderManagerExtension extension = model.getExtension( + StereotypeMetadatasProviderManagerExtension.OBJECTMODEL_EXTENSION, StereotypeMetadatasProviderManagerExtension.class); + return extension.getProvider(providerType); } } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/Model.java b/eugene/src/main/java/org/nuiton/eugene/models/Model.java index ea30ba0..7e3fe2d 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/Model.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/Model.java @@ -23,13 +23,15 @@ package org.nuiton.eugene.models; +import org.nuiton.eugene.models.extension.stereotype.WithStereotypes; +import org.nuiton.eugene.models.extension.tagvalue.WithTagValues; import org.nuiton.eugene.models.stereotype.StereotypeAble; import org.nuiton.eugene.models.tagvalue.TagValueAble; /** * Model. */ -public interface Model extends TagValueAble, StereotypeAble { +public interface Model extends TagValueAble, StereotypeAble, WithTagValues, WithStereotypes { /** * Plexus role name diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/InvalidStereotypeSyntaxException.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/InvalidStereotypeSyntaxException.java similarity index 93% copy from eugene/src/main/java/org/nuiton/eugene/models/stereotype/InvalidStereotypeSyntaxException.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/InvalidStereotypeSyntaxException.java index f751d4e..7aa8ef8 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/InvalidStereotypeSyntaxException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/InvalidStereotypeSyntaxException.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.stereotype; +package org.nuiton.eugene.models.extension.stereotype; /* * #%L @@ -26,7 +26,7 @@ package org.nuiton.eugene.models.stereotype; * Created on 5/1/14. * * @author Tony Chemit - chemit@codelutin.com - * @since 2.9 + * @since 3.0 */ public class InvalidStereotypeSyntaxException extends Exception { diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MismatchStereotypeTargetException.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/MismatchStereotypeTargetException.java similarity index 93% copy from eugene/src/main/java/org/nuiton/eugene/models/stereotype/MismatchStereotypeTargetException.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/MismatchStereotypeTargetException.java index f62b9bc..4323580 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MismatchStereotypeTargetException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/MismatchStereotypeTargetException.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.stereotype; +package org.nuiton.eugene.models.extension.stereotype; /* * #%L @@ -26,7 +26,7 @@ package org.nuiton.eugene.models.stereotype; * Created on 4/27/14. * * @author Tony Chemit - chemit@codelutin.com - * @since 2.9 + * @since 3.0 */ public class MismatchStereotypeTargetException extends Exception { diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MissingStereoTypeException.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/MissingStereoTypeException.java similarity index 61% copy from eugene/src/main/java/org/nuiton/eugene/models/stereotype/MissingStereoTypeException.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/MissingStereoTypeException.java index 1b29142..fad8714 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MissingStereoTypeException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/MissingStereoTypeException.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.stereotype; +package org.nuiton.eugene.models.extension.stereotype; /* * #%L @@ -26,6 +26,7 @@ import com.google.common.base.Joiner; import org.nuiton.eugene.models.object.ObjectModelClass; import org.nuiton.eugene.models.object.ObjectModelPackage; +import java.util.LinkedHashSet; import java.util.Set; /** @@ -49,7 +50,7 @@ public class MissingStereoTypeException extends RuntimeException { public MissingStereoTypeException(String stereoTypeName, String prefixMessage, ObjectModelPackage aPackage, ObjectModelClass aClass) { this.stereoTypeName = stereoTypeName; this.prefixMessage = prefixMessage; - this.stack = Stereotypes.getUsageStack(stereoTypeName, aPackage, aClass); + this.stack = getUsageStack(stereoTypeName, aPackage, aClass); } @Override @@ -62,4 +63,35 @@ public class MissingStereoTypeException extends RuntimeException { } + /** + * Build the stack of usage of the given stereoType. + * + * Order of usage is : model, packages (from root to final package), then class. + * + * @param stereoTypeName + * @param aPackage + * @param aClass + * @return the orderer set of stack usage. + */ + public LinkedHashSet<String> getUsageStack(String stereoTypeName, ObjectModelPackage aPackage, ObjectModelClass aClass) { + String suffix = ".stereotype=" + stereoTypeName; + LinkedHashSet<String> stack = new LinkedHashSet<>(); + + stack.add("model" + suffix); + + addPackageStereoTypes(aPackage, suffix, stack); + stack.add(aClass.getQualifiedName() + ".class" + suffix); + + return stack; + } + + protected void addPackageStereoTypes(ObjectModelPackage aPackage, String suffix, Set<String> stack) { + + if (aPackage.getParentPackage() != null) { + addPackageStereoTypes(aPackage.getParentPackage(), suffix, stack); + } + stack.add("package." + aPackage.getName() + suffix); + + } + } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeMetadata.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeMetadata.java new file mode 100644 index 0000000..cc15931 --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeMetadata.java @@ -0,0 +1,40 @@ +package org.nuiton.eugene.models.extension.stereotype; + +import java.util.Set; + +/** + * To define a stereotype metadata. + * + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface StereotypeMetadata { + + /** + * Get the stereotype name. + * + * @return the stereotype name + */ + String getName(); + + /** + * Define the types of object model api which can use this tag value. + * + * @return the set of target object model element which can accept the tag value. + */ + Set<Class<?>> getTargets(); + + /** + * Get the i18n documentation key. + * + * @return the i18n documentation key + */ + String getI18nDocumentationKey(); + + /** + * @return {@code true} if this stereotype is deprecated + */ + boolean isDeprecated(); + +} diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeMetadatasProviderManagerExtension.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeMetadatasProviderManagerExtension.java new file mode 100644 index 0000000..314cc4b --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeMetadatasProviderManagerExtension.java @@ -0,0 +1,42 @@ +package org.nuiton.eugene.models.extension.stereotype; + +import com.google.common.base.Preconditions; +import org.nuiton.eugene.models.extension.stereotype.provider.AggregateStereotypeMetadatasProvider; +import org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class StereotypeMetadatasProviderManagerExtension { + + /** + * Extension static used to identify this extension in ObjectModel. + */ + public static final String OBJECTMODEL_EXTENSION = "stereotypeMetadatasProvider"; + + protected AggregateStereotypeMetadatasProvider prodiver; + + public void setProdiver(AggregateStereotypeMetadatasProvider prodiver) { + this.prodiver = prodiver; + } + + public <T extends StereotypeMetadatasProvider> T getProvider(Class<T> providerType) { + + Preconditions.checkState(prodiver != null, "No prodiver assigned"); + + StereotypeMetadatasProvider result = null; + for (StereotypeMetadatasProvider stereotypeDefinitionProvider : prodiver) { + if (providerType.equals(stereotypeDefinitionProvider.getClass())) { + result = stereotypeDefinitionProvider; + break; + } + } + + Preconditions.checkState(result != null, "No prodiver of this type: " + providerType.getName()); + return (T) result; + + } + +} \ No newline at end of file diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeNotFoundException.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeNotFoundException.java similarity index 93% copy from eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeNotFoundException.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeNotFoundException.java index f5d9a89..d97384e 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeNotFoundException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeNotFoundException.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.stereotype; +package org.nuiton.eugene.models.extension.stereotype; /* * #%L @@ -26,7 +26,7 @@ package org.nuiton.eugene.models.stereotype; * Created on 4/27/14. * * @author Tony Chemit - chemit@codelutin.com - * @since 2.9 + * @since 3.0 */ public class StereotypeNotFoundException extends Exception { diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/Stereotypes.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeUtil.java similarity index 62% copy from eugene/src/main/java/org/nuiton/eugene/models/stereotype/Stereotypes.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeUtil.java index 2bc9553..f520ab7 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/Stereotypes.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/StereotypeUtil.java @@ -1,44 +1,20 @@ -package org.nuiton.eugene.models.stereotype; - -/* - * #%L - * EUGene :: EUGene - * %% - * Copyright (C) 2004 - 2014 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% - */ +package org.nuiton.eugene.models.extension.stereotype; import com.google.common.collect.ImmutableSet; -import org.nuiton.eugene.models.object.ObjectModelClass; import org.nuiton.eugene.models.object.ObjectModelElement; import org.nuiton.eugene.models.object.ObjectModelPackage; -import java.util.LinkedHashSet; import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; /** - * Created on 5/1/14. + * Created on 24/09/16. * * @author Tony Chemit - chemit@codelutin.com - * @since 2.9 + * @since 3.0 */ -public class Stereotypes { +public class StereotypeUtil { protected static final Pattern PACKAGE_STEREOTYPE_PATTERN = Pattern .compile("^package\\.((?:[_a-zA-Z0-9]+\\.)+)?(?:(stereotype)?)$"); @@ -68,46 +44,7 @@ public class Stereotypes { return ImmutableSet.<String>builder().add(split).build(); } - /** - * Seek for a stereotype amoung elements given using these rules: - * <ul> - * <li>Look into {@code elements} and return the first element with this stereotype found.</li> - * <li>If not found, Look into {@code elements} declaringElement (for each - * element that is a {@link ObjectModelElement} and return the first not empty tag - * element with this stereotype found.</li> - * </ul> - * <strong>Note:</strong> Order of {@code elements} is important, better then to - * always starts from specialized to more general level (for example from attribute, - * to classifier or model). - * - * @param stereotypeName tag name to find - * @param elements not null elements to test - * @return {@code true} if found stereotype, {@code false} otherwise - * @since 2.12 - */ - public static boolean findStereotype(String stereotypeName, StereotypeAble... elements) { - - boolean result = findDirectStereotype(stereotypeName, elements); - - if (result) { - return result; - } - - for (StereotypeAble element : elements) { - if (element instanceof ObjectModelElement) { - // try in declaring element - ObjectModelElement declaringElement = ((ObjectModelElement) element).getDeclaringElement(); - if (declaringElement != null) { - boolean value = findStereotype(stereotypeName, declaringElement); - if (value) { - return value; - } - } - } - } - return false; - } /** * Seek for a stereotype amoung elements given using these rules: @@ -121,16 +58,16 @@ public class Stereotypes { * @param stereotypeName stereotype to find * @param elements not null elements to test * @return {@code true} if found stereotype, {@code false} otherwise - * @since 2.12 + * @since 3.0 */ - public static boolean findDirectStereotype(String stereotypeName, StereotypeAble... elements) { + public static boolean findDirectStereotype(StereotypeMetadata stereotypeName, WithStereotypes... elements) { boolean value = false; - for (StereotypeAble element : elements) { + for (WithStereotypes element : elements) { if (element != null) { if (element instanceof ObjectModelPackage) { value = findDirectStereotype(stereotypeName, (ObjectModelPackage) element); } else { - value = element.hasStereotype(stereotypeName); + value = element.hasStereotype(stereotypeName.getName()); } if (value) { break; @@ -143,42 +80,52 @@ public class Stereotypes { } /** - * Build the stack of usage of the given stereoType. - * - * Order of usage is : model, packages (from root to final package), then class. + * Seek for a stereotype amoung elements given using these rules: + * <ul> + * <li>Look into {@code elements} and return the first element with this stereotype found.</li> + * <li>If not found, Look into {@code elements} declaringElement (for each + * element that is a {@link ObjectModelElement} and return the first not empty tag + * element with this stereotype found.</li> + * </ul> + * <strong>Note:</strong> Order of {@code elements} is important, better then to + * always starts from specialized to more general level (for example from attribute, + * to classifier or model). * - * @param stereoTypeName - * @param aPackage - * @param aClass - * @return the orderer set of stack usage. + * @param stereotypeName stereotype to find + * @param elements not null elements to test + * @return {@code true} if found stereotype, {@code false} otherwise + * @since 3.0 */ - public static LinkedHashSet<String> getUsageStack(String stereoTypeName, ObjectModelPackage aPackage, ObjectModelClass aClass) { - String suffix = ".stereotype=" + stereoTypeName ; - LinkedHashSet<String> stack = new LinkedHashSet<>(); - - stack.add("model" + suffix); + public static boolean findStereotype(StereotypeMetadata stereotypeName, WithStereotypes... elements) { - addPackageStereoTypes(aPackage, suffix, stack); - stack.add(aClass.getQualifiedName() + ".class" + suffix); - - return stack; - } + boolean result = findDirectStereotype(stereotypeName, elements); - protected static void addPackageStereoTypes(ObjectModelPackage aPackage, String suffix, Set<String> stack) { + if (result) { + return result; + } - if (aPackage.getParentPackage() != null) { - addPackageStereoTypes(aPackage.getParentPackage(), suffix, stack); + for (WithStereotypes element : elements) { + if (element instanceof ObjectModelElement) { + // try in declaring element + ObjectModelElement declaringElement = ((ObjectModelElement) element).getDeclaringElement(); + if (declaringElement != null) { + boolean value = findStereotype(stereotypeName, declaringElement); + if (value) { + return value; + } + } + } } - stack.add("package." + aPackage.getName() + suffix); + return false; } - protected static boolean findDirectStereotype(String stereotypeName, ObjectModelPackage element) { - boolean withStereotype = element.hasStereotype(stereotypeName); + protected static boolean findDirectStereotype(StereotypeMetadata stereotypeName, ObjectModelPackage element) { + boolean withStereotype = element.hasStereotype(stereotypeName.getName()); if (!withStereotype && element.getParentPackage() != null) { withStereotype = findDirectStereotype(stereotypeName, element.getParentPackage()); } return withStereotype; - } + } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeAble.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/WithStereotypes.java similarity index 92% copy from eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeAble.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/WithStereotypes.java index c9b4744..77b2f24 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeAble.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/WithStereotypes.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.stereotype; +package org.nuiton.eugene.models.extension.stereotype; /* * #%L @@ -30,7 +30,7 @@ import java.util.Set; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ -public interface StereotypeAble { +public interface WithStereotypes { /** * Returns the stereotypes names associated with this element. @@ -53,4 +53,6 @@ public interface StereotypeAble { * @param stereotype stereotype to add */ void addStereotype(String stereotype); + + void removeStereotype(String stereotype); } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/provider/AggregateStereotypeMetadatasProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/provider/AggregateStereotypeMetadatasProvider.java new file mode 100644 index 0000000..76e3602 --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/provider/AggregateStereotypeMetadatasProvider.java @@ -0,0 +1,113 @@ +package org.nuiton.eugene.models.extension.stereotype.provider; + +/* + * #%L + * EUGene :: EUGene + * %% + * Copyright (C) 2004 - 2014 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 com.google.common.base.Optional; +import com.google.common.collect.ImmutableSet; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.eugene.models.extension.stereotype.MismatchStereotypeTargetException; +import org.nuiton.eugene.models.extension.stereotype.StereotypeMetadata; +import org.nuiton.eugene.models.extension.stereotype.StereotypeNotFoundException; + +import java.util.Iterator; +import java.util.ServiceLoader; + +/** + * Created on 4/27/14. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 2.9 + */ +public class AggregateStereotypeMetadatasProvider implements StereotypeMetadatasProvider, Iterable<StereotypeMetadatasProvider> { + + /** Logger. */ + private static final Log log = LogFactory.getLog(AggregateStereotypeMetadatasProvider.class); + + protected final Iterable<StereotypeMetadatasProvider> providers; + + /** + * Obtain a new provider of stereotype definitions. + * + * @param loader the classloader to use (if none given will use the one of the current thread) + */ + public AggregateStereotypeMetadatasProvider(ClassLoader loader) { + if (loader == null) { + + // use the current thread loader + loader = Thread.currentThread().getContextClassLoader(); + } + this.providers = ServiceLoader.load(StereotypeMetadatasProvider.class, loader); + + } + + /** + * Obtain a new provider of stereotype definitions. + * + * @param providers the list of providers to use in the factory + */ + public AggregateStereotypeMetadatasProvider(Iterable<StereotypeMetadatasProvider> providers) { + this.providers = providers; + } + + @Override + public Iterator<StereotypeMetadatasProvider> iterator() { + return providers.iterator(); + } + + @Override + public ImmutableSet<StereotypeMetadata> getStereotypes() { + ImmutableSet.Builder<StereotypeMetadata> builder = ImmutableSet.builder(); + for (StereotypeMetadatasProvider tagValuesMetadatasProvider : providers) { + builder.addAll(tagValuesMetadatasProvider.getStereotypes()); + } + + return builder.build(); + } + + @Override + public void validate(String stereotypeName, Class<?> type) throws StereotypeNotFoundException, MismatchStereotypeTargetException { + for (StereotypeMetadatasProvider provider : providers) { + try { + provider.validate(stereotypeName, type); + return; + } catch (StereotypeNotFoundException e) { + // do nothing here + } + } + throw new StereotypeNotFoundException(); + + } + + @Override + public Optional<StereotypeMetadata> getStereotype(String stereotypeName) { + for (StereotypeMetadatasProvider provider : providers) { + Optional<StereotypeMetadata> result = provider.getStereotype(stereotypeName); + if (result.isPresent()) { + return result; + } + } + return Optional.absent(); + } + +} diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/provider/DefaultStereotypeMetadatasProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/provider/DefaultStereotypeMetadatasProvider.java new file mode 100644 index 0000000..e483b38 --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/provider/DefaultStereotypeMetadatasProvider.java @@ -0,0 +1,62 @@ +package org.nuiton.eugene.models.extension.stereotype.provider; + +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableSet; +import org.nuiton.eugene.models.extension.stereotype.MismatchStereotypeTargetException; +import org.nuiton.eugene.models.extension.stereotype.StereotypeMetadata; +import org.nuiton.eugene.models.extension.stereotype.StereotypeNotFoundException; + +import java.util.Set; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public abstract class DefaultStereotypeMetadatasProvider implements StereotypeMetadatasProvider { + + protected Set<StereotypeMetadata> stereotypes; + + protected DefaultStereotypeMetadatasProvider(StereotypeMetadata... stereotypes) { + this.stereotypes = ImmutableSet.copyOf(stereotypes); + } + + @Override + public Set<StereotypeMetadata> getStereotypes() { + return stereotypes; + } + + @Override + public void validate(String stereotypeName, Class<?> type) throws StereotypeNotFoundException, MismatchStereotypeTargetException { + Optional<StereotypeMetadata> def = getStereotype(stereotypeName); + + if (!def.isPresent()) { + throw new StereotypeNotFoundException(); + } + + boolean valid = false; + + for (Class<?> target : def.get().getTargets()) { + if (target.equals(type) || target.isAssignableFrom(type)) { + + // found one accepting target + valid = true; + break; + } + } + if (!valid) { + throw new MismatchStereotypeTargetException(); + } + } + + @Override + public Optional<StereotypeMetadata> getStereotype(String stereotypeName) { + for (StereotypeMetadata metadata : stereotypes) { + if (stereotypeName.equals(metadata.getName())) { + return Optional.of(metadata); + } + } + return Optional.absent(); + } + +} \ No newline at end of file diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/provider/StereotypeMetadatasProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/provider/StereotypeMetadatasProvider.java new file mode 100644 index 0000000..4e3fdf4 --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/stereotype/provider/StereotypeMetadatasProvider.java @@ -0,0 +1,23 @@ +package org.nuiton.eugene.models.extension.stereotype.provider; + +import com.google.common.base.Optional; +import org.nuiton.eugene.models.extension.stereotype.MismatchStereotypeTargetException; +import org.nuiton.eugene.models.extension.stereotype.StereotypeMetadata; +import org.nuiton.eugene.models.extension.stereotype.StereotypeNotFoundException; + +import java.util.Set; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface StereotypeMetadatasProvider { + + Set<StereotypeMetadata> getStereotypes(); + + void validate(String stereotypeName, Class<?> type) throws StereotypeNotFoundException, MismatchStereotypeTargetException; + + Optional<StereotypeMetadata> getStereotype(String stereotypeName); + +} \ No newline at end of file diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/InvalidTagValueSyntaxException.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/InvalidTagValueSyntaxException.java similarity index 94% copy from eugene/src/main/java/org/nuiton/eugene/models/tagvalue/InvalidTagValueSyntaxException.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/InvalidTagValueSyntaxException.java index 7585d91..d5aee3d 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/InvalidTagValueSyntaxException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/InvalidTagValueSyntaxException.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.tagvalue; +package org.nuiton.eugene.models.extension.tagvalue; /* * #%L diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MismatchTagValueTargetException.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/MismatchTagValueTargetException.java similarity index 94% copy from eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MismatchTagValueTargetException.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/MismatchTagValueTargetException.java index 9c2570f..b84077c 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MismatchTagValueTargetException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/MismatchTagValueTargetException.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.tagvalue; +package org.nuiton.eugene.models.extension.tagvalue; /* * #%L diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MissingTagValueException.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/MissingTagValueException.java similarity index 53% copy from eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MissingTagValueException.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/MissingTagValueException.java index fbf0369..c3275b8 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MissingTagValueException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/MissingTagValueException.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.tagvalue; +package org.nuiton.eugene.models.extension.tagvalue; /* * #%L @@ -26,6 +26,7 @@ import com.google.common.base.Joiner; import org.nuiton.eugene.models.object.ObjectModelClass; import org.nuiton.eugene.models.object.ObjectModelPackage; +import java.util.LinkedHashSet; import java.util.Set; /** @@ -52,16 +53,48 @@ public class MissingTagValueException extends RuntimeException { this.tagValueName = tagValueName; this.tagValueValue = tagValueValue; this.prefixMessage = prefixMessage; - this.stack = TagValues.getUsageStack(tagValueName, tagValueValue, aPackage, aClass); + this.stack = getUsageStack(tagValueName, tagValueValue, aPackage, aClass); } @Override public String toString() { return "\n\n" + prefixMessage - + "\n==========================================================================================" - + "\n" + Joiner.on("\n").join(stack) - + "\n=========================================================================================="; + + "\n==========================================================================================" + + "\n" + Joiner.on("\n").join(stack) + + "\n=========================================================================================="; + + } + + /** + * Build the stack of usage of the given tag value. + * + * Order of usage is : model, packages (from root to final package), then class. + * + * @param tagValueName + * @param tagValueValue + * @param aPackage + * @param aClass + * @return the orderer set of stack usage. + */ + protected LinkedHashSet<String> getUsageStack(String tagValueName, String tagValueValue, ObjectModelPackage aPackage, ObjectModelClass aClass) { + String suffix = ".tagvalue." + tagValueName + "=" + tagValueValue; + LinkedHashSet<String> stack = new LinkedHashSet<>(); + + stack.add("model" + suffix); + + addPackageTagValue(aPackage, suffix, stack); + stack.add(aClass.getQualifiedName() + ".class" + suffix); + + return stack; + } + + protected void addPackageTagValue(ObjectModelPackage aPackage, String suffix, Set<String> stack) { + + if (aPackage.getParentPackage() != null) { + addPackageTagValue(aPackage.getParentPackage(), suffix, stack); + } + stack.add("package." + aPackage.getName() + suffix); } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueMetadata.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueMetadata.java new file mode 100644 index 0000000..6d0a86b --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueMetadata.java @@ -0,0 +1,51 @@ +package org.nuiton.eugene.models.extension.tagvalue; + +import org.nuiton.eugene.models.extension.tagvalue.matcher.TagValueDefinitionMatcher; + +import java.util.Set; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface TagValueMetadata { + + /** + * Get the stereotype name. + * + * @return the stereotype name + */ + String getName(); + + /** + * Define the types of object model api which can use this tag value. + * + * @return the set of target object model element which can accept the tag value. + */ + Set<Class<?>> getTargets(); + + /** + * Get the i18n documentation key. + * + * @return the i18n documentation key + */ + String getI18nDocumentationKey(); + + /** + * @return default value for this tag value + */ + String getDefaultValue(); + + /** + * @return {@code true} if this stereotype is deprecated + */ + boolean isDeprecated(); + + /** + * @return the tag value type + */ + Class<?> getType(); + + Class<? extends TagValueDefinitionMatcher> getMatcherClass(); +} diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueMetadatasProviderManagerExtension.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueMetadatasProviderManagerExtension.java new file mode 100644 index 0000000..e831420 --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueMetadatasProviderManagerExtension.java @@ -0,0 +1,42 @@ +package org.nuiton.eugene.models.extension.tagvalue; + +import com.google.common.base.Preconditions; +import org.nuiton.eugene.models.extension.tagvalue.provider.AggregateTagValueMetadatasProvider; +import org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class TagValueMetadatasProviderManagerExtension { + + /** + * Extension static used to identify this extension in ObjectModel. + */ + public static final String OBJECTMODEL_EXTENSION = "tagValueMetadatasProvider"; + + protected AggregateTagValueMetadatasProvider prodiver; + + public void setProdiver(AggregateTagValueMetadatasProvider prodiver) { + this.prodiver = prodiver; + } + + public <T extends TagValueMetadatasProvider> T getProvider(Class<T> providerType) { + + Preconditions.checkState(prodiver != null, "No prodiver assigned"); + + TagValueMetadatasProvider result = null; + for (TagValueMetadatasProvider stereotypeDefinitionProvider : prodiver) { + if (providerType.equals(stereotypeDefinitionProvider.getClass())) { + result = stereotypeDefinitionProvider; + break; + } + } + + Preconditions.checkState(result != null, "No prodiver of this type: " + providerType.getName()); + return (T) result; + + } + +} \ No newline at end of file diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueNotFoundException.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueNotFoundException.java similarity index 94% copy from eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueNotFoundException.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueNotFoundException.java index 118267f..bff9d2d 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueNotFoundException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueNotFoundException.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.tagvalue; +package org.nuiton.eugene.models.extension.tagvalue; /* * #%L diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueUtil.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueUtil.java new file mode 100644 index 0000000..9a40b42 --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/TagValueUtil.java @@ -0,0 +1,193 @@ +package org.nuiton.eugene.models.extension.tagvalue; + +import org.apache.commons.lang3.StringUtils; +import org.nuiton.eugene.models.object.ObjectModelElement; +import org.nuiton.eugene.models.object.ObjectModelPackage; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class TagValueUtil { + + /** + * Pattern to define tag values authorized at classifier level in the model + * properties file. + * + * L'expression réguliere match les chaines de type + * <package.ClassName>.<class|attribute|operation>.[name].<stereotype|tagvalue>.[tag] + * fr.isisfish.entities.Population.class.stereotype=entity + * fr.isisfish.entities.Population.class.tagvalue.persistenceType=flatfile + * fr.isisfish.entities.Population.attribute.name.stereotype=... + * fr.isisfish.entities.Population.attribute.name.tagvalue.pk=topiaId + * fr.isisfish.entities.Population.operation.getRegion.stereotype=... + * fr.isisfish.entities.Population.operation.getRegion.tagvalue.pk=... + */ + protected static final Pattern TAG_VALUE_PATTERN = + Pattern.compile("^((?:[_a-zA-Z0-9]+\\.)+(?:_?[A-Z][_a-zA-Z0-9]*\\.)+)(?:(class|attribute|operation))\\.(?:([_a-zA-Z0-9]+)\\.)?(?:(tagvalue|tagValue)?)\\.((?:[_a-zA-Z0-9]+)+(?:\\.?[_a-zA-Z0-9]+)*)?$"); + + /** + * Pattern to define tag values authorized at model level in the model + * properties file. + */ + protected static final Pattern MODEL_TAG_VALUE_PATTERN = Pattern.compile( + "^model\\.(?:(tagvalue|tagValue)?)\\.((?:[_a-zA-Z0-9]+)+(?:\\.?[_a-zA-Z0-9]+)*)$"); + + /** + * Pattern to define tag values authorized at model level in the model + * properties file. + */ + protected static final Pattern PACKAGE_TAG_VALUE_PATTERN = Pattern.compile( + "^package\\.((?:[_a-zA-Z0-9]+\\.)+)(?:(tagvalue|tagValue)?)\\.((?:[_a-zA-Z0-9]+)+(?:\\.?[_a-zA-Z0-9]+)*)$"); + + public static Matcher getModelMatcher(String key) throws InvalidTagValueSyntaxException { + Matcher matcher = MODEL_TAG_VALUE_PATTERN.matcher(key); + if (!matcher.find()) { + throw new InvalidTagValueSyntaxException(); + } + return matcher; + } + + public static Matcher getPackageMatcher(String key) throws InvalidTagValueSyntaxException { + Matcher matcher = PACKAGE_TAG_VALUE_PATTERN.matcher(key); + if (!matcher.find()) { + throw new InvalidTagValueSyntaxException(); + } + return matcher; + } + + public static Matcher getMatcher(String key) throws InvalidTagValueSyntaxException { + Matcher matcher = TAG_VALUE_PATTERN.matcher(key); + if (!matcher.find()) { + throw new InvalidTagValueSyntaxException(); + } + return matcher; + } + + /** + * Seek for a tag value amoung elements given using these rules: + * <ul> + * <li>Look into {@code elements} and return the first not empty tag value found.</li> + * <li>If not found, Look into {@code elements} declaringElement (for each + * element that is a {@link ObjectModelElement} and return the first not empty tag + * value found.</li> + * <li>If not found return {@code defaultValue}</li> + * </ul> + * <strong>Note:</strong> Order of {@code elements} is important, better then to + * always starts from specialized to more general level (for example from attribute, + * to classifier or model). + * + * @param tagName tag name to find + * @param elements not null elements to test + * @return found tag value or {@code null} if not found + * @since 3.0 + */ + public static String findTagValue(TagValueMetadata tagName, WithTagValues... elements) { + String result = findDirectTagValue(tagName, elements); + + if (result != null) { + return result; + } + + for (WithTagValues element : elements) { + if (element instanceof ObjectModelElement) { + // try in declaring element + ObjectModelElement declaringElement = ((ObjectModelElement) element).getDeclaringElement(); + if (declaringElement != null) { + String value = findNotEmptyTagValue(tagName, declaringElement); + if (value != null) { + return value; + } + } + } + } + return tagName.getDefaultValue(); + } + + public static boolean findBooleanTagValue(TagValueMetadata tagName, WithTagValues... elements) { + String value = findTagValue(tagName, elements); + return value != null && "true".equalsIgnoreCase(value); + } + + /** + * Seek for a Boolean tag value. + * + * Will first the tag value using the method {@link #findTagValue(TagValueMetadata, WithTagValues...)}. + * + * If not found, return {@code null}, otherwise return boolean value (case is ignored). + * + * <strong>Note:</strong> Order of {@code elements} is important, better then to + * always starts from specialized to more general level (for example from attribute, + * to classifier or model). + * + * @param tagName tag name to find + * @param elements not null elements to test + * @return found boolean tag value or {@code null} if tag value not found. + * @since 3.0 + */ + public static Boolean findNullableBooleanTagValue(TagValueMetadata tagName, WithTagValues... elements) { + String value = findTagValue(tagName, elements); + return value == null ? null : "true".equalsIgnoreCase(value); + } + + /** + * Seek for a tag value amoung elements given using these rules: + * <ul> + * <li>Look into {@code elements} and return the first not empty tag value found.</li> + * <li>If not found return {@code defaultValue}</li> + * </ul> + * <strong>Note:</strong> Order of {@code elements} is important, better then to + * always starts from specialized to more general level (for example from attribute, + * to classifier or model). + * + * @param tagName tag name to find + * @param elements not null elements to test + * @return found tag value or {@code null} if not found + * @since 3.0 + */ + public static String findDirectTagValue(TagValueMetadata tagName, WithTagValues... elements) { + + for (WithTagValues element : elements) { + String value = findNotEmptyTagValue(tagName, element); + if (value != null) { + return value; + } + } + + return tagName.getDefaultValue(); + } + + public static String findNotEmptyTagValue(TagValueMetadata tagName, WithTagValues element) { + + String value = null; + if (element != null) { + if (element instanceof ObjectModelPackage) { + value = findNotEmptyTagValue(tagName, (ObjectModelPackage) element); + } else { + value = element.getTagValue(tagName.getName()); + if (StringUtils.isEmpty(value)) { + value = null; + } + } + } + return value; + + } + + protected static String findNotEmptyTagValue(TagValueMetadata tagName, ObjectModelPackage element) { + + String value = element.getTagValue(tagName.getName()); + if (StringUtils.isEmpty(value)) { + value = null; + } + if (value == null && element.getParentPackage() != null) { + value = findNotEmptyTagValue(tagName, element.getParentPackage()); + } + return value; + + } +} diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueAble.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/WithTagValues.java similarity index 94% copy from eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueAble.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/WithTagValues.java index 734e532..9e37507 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueAble.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/WithTagValues.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.tagvalue; +package org.nuiton.eugene.models.extension.tagvalue; /* * #%L @@ -30,7 +30,7 @@ import java.util.Map; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ -public interface TagValueAble { +public interface WithTagValues { /** * Returns the tagValues associated with this element. @@ -66,4 +66,7 @@ public interface TagValueAble { * @return a boolean indicating whether this element has a tagValue corresponding to the given name, or not. */ boolean hasTagValue(String tagValue); + + void removeTagValue(String tagvalue); + } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/EqualsTagValueNameMatcher.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/matcher/EqualsTagValueNameMatcher.java similarity index 72% copy from eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/EqualsTagValueNameMatcher.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/matcher/EqualsTagValueNameMatcher.java index b6fe7a7..e0406f9 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/EqualsTagValueNameMatcher.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/matcher/EqualsTagValueNameMatcher.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.tagvalue.matcher; +package org.nuiton.eugene.models.extension.tagvalue.matcher; /* * #%L @@ -22,9 +22,9 @@ package org.nuiton.eugene.models.tagvalue.matcher; * #L% */ -import org.nuiton.eugene.models.tagvalue.TagValueDefinition; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; -import java.util.Map; +import java.util.Set; /** * Created on 4/26/14. @@ -34,12 +34,12 @@ import java.util.Map; */ public class EqualsTagValueNameMatcher extends TagValueDefinitionMatcher { - public EqualsTagValueNameMatcher(Map<String, TagValueDefinition> tagValueDefinitionMap) { + public EqualsTagValueNameMatcher(Set<TagValueMetadata> tagValueDefinitionMap) { super(tagValueDefinitionMap); } @Override - protected boolean accept(String tagValueName, Map.Entry<String, TagValueDefinition> entry) { - return entry.getKey().equals(tagValueName); + protected boolean accept(String tagValueName, TagValueMetadata entry) { + return entry.getName().equals(tagValueName); } } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/StartsWithTagNameMatcher.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/matcher/StartsWithTagNameMatcher.java similarity index 72% copy from eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/StartsWithTagNameMatcher.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/matcher/StartsWithTagNameMatcher.java index 24b0643..6b23fdf 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/StartsWithTagNameMatcher.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/matcher/StartsWithTagNameMatcher.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.tagvalue.matcher; +package org.nuiton.eugene.models.extension.tagvalue.matcher; /* * #%L @@ -22,9 +22,9 @@ package org.nuiton.eugene.models.tagvalue.matcher; * #L% */ -import org.nuiton.eugene.models.tagvalue.TagValueDefinition; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; -import java.util.Map; +import java.util.Set; /** * Created on 4/26/14. @@ -34,13 +34,13 @@ import java.util.Map; */ public class StartsWithTagNameMatcher extends TagValueDefinitionMatcher { - public StartsWithTagNameMatcher(Map<String, TagValueDefinition> tagValueDefinitionMap) { + public StartsWithTagNameMatcher(Set<TagValueMetadata> tagValueDefinitionMap) { super(tagValueDefinitionMap); } @Override - protected boolean accept(String tagValueName, Map.Entry<String, TagValueDefinition> entry) { - return tagValueName.startsWith(entry.getKey()); + protected boolean accept(String tagValueName, TagValueMetadata entry) { + return tagValueName.startsWith(entry.getName()); } } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/TagValueDefinitionMatcher.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/matcher/TagValueDefinitionMatcher.java similarity index 57% copy from eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/TagValueDefinitionMatcher.java copy to eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/matcher/TagValueDefinitionMatcher.java index c899ce6..4d92b76 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/TagValueDefinitionMatcher.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/matcher/TagValueDefinitionMatcher.java @@ -1,4 +1,4 @@ -package org.nuiton.eugene.models.tagvalue.matcher; +package org.nuiton.eugene.models.extension.tagvalue.matcher; /* * #%L @@ -22,10 +22,10 @@ package org.nuiton.eugene.models.tagvalue.matcher; * #L% */ -import com.google.common.collect.ImmutableMap; -import org.nuiton.eugene.models.tagvalue.TagValueDefinition; +import com.google.common.collect.ImmutableSet; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; -import java.util.Map; +import java.util.Set; /** * To match a Tag value name. @@ -37,24 +37,24 @@ import java.util.Map; */ public abstract class TagValueDefinitionMatcher { - protected Map<String, TagValueDefinition> tagValueDefinitionMap; + protected Set<TagValueMetadata> tagValueDefinitionMap; - public TagValueDefinitionMatcher(Map<String, TagValueDefinition> tagValueDefinitionMap) { - this.tagValueDefinitionMap = ImmutableMap.<String, TagValueDefinition>builder().putAll(tagValueDefinitionMap).build(); + public TagValueDefinitionMatcher(Set<TagValueMetadata> tagValueDefinitionMap) { + this.tagValueDefinitionMap = ImmutableSet.copyOf(tagValueDefinitionMap); } - public TagValueDefinition match(String tagValueName) { - TagValueDefinition tagValueDefinition = null; - for (Map.Entry<String, TagValueDefinition> entry : tagValueDefinitionMap.entrySet()) { + public TagValueMetadata match(String tagValueName) { + TagValueMetadata tagValueDefinition = null; + for (TagValueMetadata entry : tagValueDefinitionMap) { if (accept(tagValueName, entry)) { // found tag value definition - tagValueDefinition = entry.getValue(); + tagValueDefinition = entry; break; } } return tagValueDefinition; } - protected abstract boolean accept(String tagValueName, Map.Entry<String, TagValueDefinition> entry); + protected abstract boolean accept(String tagValueName, TagValueMetadata entry); } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/provider/AggregateTagValueMetadatasProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/provider/AggregateTagValueMetadatasProvider.java new file mode 100644 index 0000000..6167328 --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/provider/AggregateTagValueMetadatasProvider.java @@ -0,0 +1,91 @@ +package org.nuiton.eugene.models.extension.tagvalue.provider; + +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableSet; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.eugene.models.extension.tagvalue.MismatchTagValueTargetException; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; +import org.nuiton.eugene.models.extension.tagvalue.TagValueNotFoundException; + +import java.util.Iterator; +import java.util.ServiceLoader; +import java.util.Set; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class AggregateTagValueMetadatasProvider implements TagValueMetadatasProvider, Iterable<TagValueMetadatasProvider> { + + /** Logger. */ + private static final Log log = LogFactory.getLog(AggregateTagValueMetadatasProvider.class); + + protected final Iterable<TagValueMetadatasProvider> providers; + + /** + * Obtain a new provider of tag values definitions. + * + * @param loader the classloader to use (if none given will use the one of the current thread) + */ + public AggregateTagValueMetadatasProvider(ClassLoader loader) { + if (loader == null) { + + // use the current thread loader + loader = Thread.currentThread().getContextClassLoader(); + } + this.providers = ServiceLoader.load(TagValueMetadatasProvider.class, loader); + } + + /** + * Obtain a new provider of tag values definitions. + * + * @param providers the list of providers to use in the factory + */ + public AggregateTagValueMetadatasProvider(Iterable<TagValueMetadatasProvider> providers) { + Preconditions.checkNotNull(providers); + this.providers = providers; + } + + @Override + public Iterator<TagValueMetadatasProvider> iterator() { + return providers.iterator(); + } + + @Override + public Set<TagValueMetadata> getTagValues() { + ImmutableSet.Builder<TagValueMetadata> builder = ImmutableSet.builder(); + for (TagValueMetadatasProvider tagValuesMetadatasProvider : providers) { + builder.addAll(tagValuesMetadatasProvider.getTagValues()); + } + + return builder.build(); + } + + @Override + public Optional<TagValueMetadata> getTagValue(String tagValueName) { + for (TagValueMetadatasProvider provider : providers) { + Optional<TagValueMetadata> result = provider.getTagValue(tagValueName); + if (result.isPresent()) { + return result; + } + } + return Optional.absent(); + } + + @Override + public void validate(String tagValueName, Class<?> type) throws TagValueNotFoundException, MismatchTagValueTargetException { + for (TagValueMetadatasProvider provider : providers) { + try { + provider.validate(tagValueName, type); + return; + } catch (TagValueNotFoundException e) { + // do nothing here + } + } + throw new TagValueNotFoundException(); + } + +} diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/provider/DefaultTagValueMetadatasProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/provider/DefaultTagValueMetadatasProvider.java new file mode 100644 index 0000000..8524dbc --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/provider/DefaultTagValueMetadatasProvider.java @@ -0,0 +1,81 @@ +package org.nuiton.eugene.models.extension.tagvalue.provider; + +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableSet; +import org.nuiton.eugene.models.extension.tagvalue.MismatchTagValueTargetException; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; +import org.nuiton.eugene.models.extension.tagvalue.TagValueNotFoundException; +import org.nuiton.eugene.models.extension.tagvalue.matcher.EqualsTagValueNameMatcher; +import org.nuiton.eugene.models.extension.tagvalue.matcher.StartsWithTagNameMatcher; +import org.nuiton.eugene.models.extension.tagvalue.matcher.TagValueDefinitionMatcher; + +import java.util.LinkedHashSet; +import java.util.Set; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class DefaultTagValueMetadatasProvider implements TagValueMetadatasProvider { + + protected final Set<TagValueMetadata> tagValues; + protected final Set<TagValueDefinitionMatcher> matcher; + + public DefaultTagValueMetadatasProvider(TagValueMetadata... tagValues) { + this.tagValues = ImmutableSet.copyOf(tagValues); + this.matcher = ImmutableSet.of( + new EqualsTagValueNameMatcher(getDefinitionForMatcher(EqualsTagValueNameMatcher.class)), + new StartsWithTagNameMatcher(getDefinitionForMatcher(StartsWithTagNameMatcher.class))); + } + + @Override + public Set<TagValueMetadata> getTagValues() { + return tagValues; + } + + @Override + public void validate(String tagValueName, Class<?> type) throws TagValueNotFoundException, MismatchTagValueTargetException { + Optional<TagValueMetadata> def = getTagValue(tagValueName); + + if (!def.isPresent()) { + throw new TagValueNotFoundException(); + } + + boolean valid = false; + + for (Class<?> target : def.get().getTargets()) { + if (target.equals(type) || target.isAssignableFrom(type)) { + + // found one accepting target + valid = true; + break; + } + } + + if (!valid) { + throw new MismatchTagValueTargetException(); + } + } + + @Override + public Optional<TagValueMetadata> getTagValue(String tagValueName) { + for (TagValueDefinitionMatcher tagValueDefinitionMatcher : matcher) { + TagValueMetadata def = tagValueDefinitionMatcher.match(tagValueName); + if (def != null) + return Optional.of(def); + } + return Optional.absent(); + } + + protected <M extends TagValueDefinitionMatcher> Set<TagValueMetadata> getDefinitionForMatcher(Class<M> matcherType) { + Set<TagValueMetadata> result = new LinkedHashSet<>(); + for (TagValueMetadata entry : getTagValues()) { + if (matcherType.equals(entry.getMatcherClass())) { + result.add(entry); + } + } + return result; + } + +} diff --git a/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/provider/TagValueMetadatasProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/provider/TagValueMetadatasProvider.java new file mode 100644 index 0000000..67ef9ec --- /dev/null +++ b/eugene/src/main/java/org/nuiton/eugene/models/extension/tagvalue/provider/TagValueMetadatasProvider.java @@ -0,0 +1,23 @@ +package org.nuiton.eugene.models.extension.tagvalue.provider; + +import com.google.common.base.Optional; +import org.nuiton.eugene.models.extension.tagvalue.MismatchTagValueTargetException; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; +import org.nuiton.eugene.models.extension.tagvalue.TagValueNotFoundException; + +import java.util.Set; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface TagValueMetadatasProvider { + + Set<TagValueMetadata> getTagValues(); + + void validate(String tagValueName, Class<?> type) throws TagValueNotFoundException, MismatchTagValueTargetException; + + Optional<TagValueMetadata> getTagValue(String tagValueName); + +} diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelElement.java b/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelElement.java index 69b50ab..27e949f 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelElement.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelElement.java @@ -22,6 +22,8 @@ package org.nuiton.eugene.models.object; +import org.nuiton.eugene.models.extension.stereotype.WithStereotypes; +import org.nuiton.eugene.models.extension.tagvalue.WithTagValues; import org.nuiton.eugene.models.stereotype.StereotypeAble; import org.nuiton.eugene.models.tagvalue.TagValueAble; @@ -32,7 +34,7 @@ import java.util.List; * * @author Cédric Pineau - pineau@codelutin.com */ -public interface ObjectModelElement extends TagValueAble, StereotypeAble { +public interface ObjectModelElement extends TagValueAble, StereotypeAble, WithTagValues, WithStereotypes { /** * Returns the name of this element. diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelPackage.java b/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelPackage.java index a434200..c37505c 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelPackage.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelPackage.java @@ -22,6 +22,8 @@ package org.nuiton.eugene.models.object; * #L% */ +import org.nuiton.eugene.models.extension.stereotype.WithStereotypes; +import org.nuiton.eugene.models.extension.tagvalue.WithTagValues; import org.nuiton.eugene.models.stereotype.StereotypeAble; import org.nuiton.eugene.models.tagvalue.TagValueAble; @@ -33,7 +35,7 @@ import java.util.List; * @author Tony Chemit - chemit@codelutin.com * @since 2.12 */ -public interface ObjectModelPackage extends TagValueAble, StereotypeAble { +public interface ObjectModelPackage extends TagValueAble, StereotypeAble, WithTagValues, WithStereotypes { /** * @return the name of this package. @@ -41,13 +43,11 @@ public interface ObjectModelPackage extends TagValueAble, StereotypeAble { String getName(); /** - * * @return the number of sub packages. (0 for a root package). */ int getNumberOfSubPackages(); /** - * * @return parent package or {@code null} if the package is a root package. */ ObjectModelPackage getParentPackage(); diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/reader/AbstractObjectModelReader.java b/eugene/src/main/java/org/nuiton/eugene/models/object/reader/AbstractObjectModelReader.java index 53b122b..403183f 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/reader/AbstractObjectModelReader.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/reader/AbstractObjectModelReader.java @@ -26,9 +26,21 @@ import com.google.common.collect.Sets; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.nuiton.eugene.EugeneTagValues; +import org.nuiton.eugene.EugeneCoreTagValues; import org.nuiton.eugene.ModelHelper; import org.nuiton.eugene.ModelReader; +import org.nuiton.eugene.models.extension.stereotype.InvalidStereotypeSyntaxException; +import org.nuiton.eugene.models.extension.stereotype.MismatchStereotypeTargetException; +import org.nuiton.eugene.models.extension.stereotype.StereotypeMetadata; +import org.nuiton.eugene.models.extension.stereotype.StereotypeNotFoundException; +import org.nuiton.eugene.models.extension.stereotype.StereotypeUtil; +import org.nuiton.eugene.models.extension.stereotype.provider.AggregateStereotypeMetadatasProvider; +import org.nuiton.eugene.models.extension.tagvalue.InvalidTagValueSyntaxException; +import org.nuiton.eugene.models.extension.tagvalue.MismatchTagValueTargetException; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; +import org.nuiton.eugene.models.extension.tagvalue.TagValueNotFoundException; +import org.nuiton.eugene.models.extension.tagvalue.TagValueUtil; +import org.nuiton.eugene.models.extension.tagvalue.provider.AggregateTagValueMetadatasProvider; import org.nuiton.eugene.models.object.ObjectModel; import org.nuiton.eugene.models.object.ObjectModelAssociationClass; import org.nuiton.eugene.models.object.ObjectModelAttribute; @@ -42,16 +54,7 @@ import org.nuiton.eugene.models.object.xml.ObjectModelAssociationClassImpl; import org.nuiton.eugene.models.object.xml.ObjectModelClassifierImpl; import org.nuiton.eugene.models.object.xml.ObjectModelImpl; import org.nuiton.eugene.models.object.xml.ObjectModelPackageImpl; -import org.nuiton.eugene.models.stereotype.InvalidStereotypeSyntaxException; -import org.nuiton.eugene.models.stereotype.MismatchStereotypeTargetException; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProviders; -import org.nuiton.eugene.models.stereotype.StereotypeNotFoundException; import org.nuiton.eugene.models.stereotype.Stereotypes; -import org.nuiton.eugene.models.tagvalue.InvalidTagValueSyntaxException; -import org.nuiton.eugene.models.tagvalue.MismatchTagValueTargetException; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProviders; -import org.nuiton.eugene.models.tagvalue.TagValueNotFoundException; -import org.nuiton.eugene.models.tagvalue.TagValues; import org.nuiton.util.FileUtil; import org.nuiton.util.RecursiveProperties; import org.nuiton.util.StringUtil; @@ -103,17 +106,17 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> protected void beforeReadFile(File... files) { - if (tagValueDefinitionProvider == null) { + if (tagValueMetadatasProvider == null) { if (log.isDebugEnabled()) { log.debug("No tag value provider filled, will instanciate a new default one"); } - setTagValueDefinitionProvider(TagValueDefinitionProviders.newProvider(getClass().getClassLoader(), false)); + setTagValueMetadatasProvider(new AggregateTagValueMetadatasProvider(getClass().getClassLoader())); } - if (stereotypeDefinitionProvider == null) { + if (stereotypeMetadatasProvider == null) { if (log.isDebugEnabled()) { log.debug("No stereotype provider filled, will instanciate a new default one"); } - setStereotypeDefinitionProvider(StereotypeDefinitionProviders.newProvider(getClass().getClassLoader(), false)); + setStereotypeMetadatasProvider(new AggregateStereotypeMetadatasProvider(getClass().getClassLoader())); } } @@ -273,7 +276,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> // package stereotype Matcher matcher; try { - matcher = Stereotypes.getPackageMatcher(key); + matcher = StereotypeUtil.getPackageMatcher(key); } catch (InvalidStereotypeSyntaxException e) { String message = "Invalid stereotype [" + key + "] : syntax is not correct."; if (strictLoading) { @@ -296,7 +299,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> // target real type Class<?> targetType = getTargetType(target); - Set<String> stereotypes = Stereotypes.getStereotypes(value); + Set<String> stereotypes = StereotypeUtil.getStereotypes(value); for (String stereotype : stereotypes) { boolean loaded = loadPackageStereotype(model, key, fqn, targetType, stereotype); safe &= loaded; @@ -326,7 +329,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> // check key is ok Matcher matcher; try { - matcher = Stereotypes.getMatcher(key); + matcher = StereotypeUtil.getMatcher(key); } catch (InvalidStereotypeSyntaxException e) { String message = "Invalid stereotype [" + key + "] : syntax is not correct."; if (strictLoading) { @@ -350,7 +353,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> // target real type Class<?> targetType = getTargetType(target); - Set<String> stereotypes = Stereotypes.getStereotypes(value); + Set<String> stereotypes = StereotypeUtil.getStereotypes(value); for (String stereotype : stereotypes) { boolean loaded = loadStereotype(model, key, fqn, target, targetName, targetType, stereotype); safe &= loaded; @@ -458,7 +461,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> Matcher matcher; try { - matcher = TagValues.getModelMatcher(key); + matcher = TagValueUtil.getModelMatcher(key); } catch (InvalidTagValueSyntaxException e) { String message = "Invalid model tag value [" + key + "] : only tagvalue or tagValue is allowed on model in properties"; if (isStrictLoading()) { @@ -478,7 +481,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> boolean safe = false; try { - tagValueDefinitionProvider.validate(tag, ObjectModel.class); + tagValueMetadatasProvider.validate(tag, ObjectModel.class); safe = true; } catch (TagValueNotFoundException e) { String message = "Invalid model tag value [" + key + "] : the tagvalue '" + tag + "' is unknown."; @@ -507,7 +510,8 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> if (safe) { // test if tagValue is deprecated - boolean deprecated = tagValueDefinitionProvider.isDeprecated(tag); + TagValueMetadata tagValueMetadata = tagValueMetadatasProvider.getTagValue(tag).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated tagValue usage [" + key + "] : " + value); @@ -521,7 +525,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> } ObjectModelImpl modelImpl = (ObjectModelImpl) model; - if (tag.equals(EugeneTagValues.TAG_VERSION)) { + if (tag.equals(EugeneCoreTagValues.Store.version.getName())) { // push directly the version in the model version property modelImpl.setVersion(value); @@ -538,7 +542,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> Matcher matcher; try { - matcher = TagValues.getPackageMatcher(key); + matcher = TagValueUtil.getPackageMatcher(key); } catch (InvalidTagValueSyntaxException e) { String message = "Invalid package tag value [" + key + "]"; if (isStrictLoading()) { @@ -560,7 +564,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> boolean safe = false; try { - tagValueDefinitionProvider.validate(tag, ObjectModelPackage.class); + tagValueMetadatasProvider.validate(tag, ObjectModelPackage.class); safe = true; } catch (TagValueNotFoundException e) { String message = "Invalid model tag value [" + key + "] : the tagvalue '" + tag + "' is unknown."; @@ -589,7 +593,8 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> if (safe) { // test if tagValue is deprecated - boolean deprecated = tagValueDefinitionProvider.isDeprecated(tag); + TagValueMetadata tagValueMetadata = tagValueMetadatasProvider.getTagValue(tag).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated tagValue usage [" + key + "] : " + value); @@ -614,7 +619,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> protected boolean loadTagValue(ObjectModel model, String key, String value) { Matcher matcher; try { - matcher = TagValues.getMatcher(key); + matcher = TagValueUtil.getMatcher(key); } catch (InvalidTagValueSyntaxException e) { String message = "Invalid tag value [" + key + "] : syntax is not correct."; @@ -653,7 +658,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> boolean safe = false; try { - tagValueDefinitionProvider.validate(tag, targetType); + tagValueMetadatasProvider.validate(tag, targetType); safe = true; } catch (TagValueNotFoundException e) { @@ -685,7 +690,8 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> if (safe) { // test if tagValue is deprecated - boolean deprecated = tagValueDefinitionProvider.isDeprecated(tag); + TagValueMetadata tagValueMetadata = tagValueMetadatasProvider.getTagValue(tag).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated tagValue usage [" + key + "] : " + value); @@ -738,7 +744,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> boolean safe = false; try { - stereotypeDefinitionProvider.validate(stereotype, ObjectModel.class); + stereotypeMetadatasProvider.validate(stereotype, ObjectModel.class); safe = true; } catch (StereotypeNotFoundException e) { @@ -768,7 +774,8 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> if (safe) { // test if stereotype is deprecated - boolean deprecated = stereotypeDefinitionProvider.isDeprecated(stereotype); + StereotypeMetadata tagValueMetadata = stereotypeMetadatasProvider.getStereotype(stereotype).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated model stereotype usage: " + stereotype); @@ -801,7 +808,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> boolean safe = false; try { - stereotypeDefinitionProvider.validate(stereotype, targetType); + stereotypeMetadatasProvider.validate(stereotype, targetType); safe = true; } catch (StereotypeNotFoundException e) { @@ -831,7 +838,9 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> if (safe) { // test if stereotype is deprecated - boolean deprecated = stereotypeDefinitionProvider.isDeprecated(stereotype); + StereotypeMetadata tagValueMetadata = stereotypeMetadatasProvider.getStereotype(stereotype).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); + if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated stereotype usage [" + key + "] : " + stereotype); @@ -886,7 +895,7 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> boolean safe = false; try { - stereotypeDefinitionProvider.validate(stereotype, targetType); + stereotypeMetadatasProvider.validate(stereotype, targetType); safe = true; } catch (StereotypeNotFoundException e) { @@ -916,7 +925,9 @@ public abstract class AbstractObjectModelReader extends ModelReader<ObjectModel> if (safe) { // test if tagValue is deprecated - boolean deprecated = stereotypeDefinitionProvider.isDeprecated(stereotype); + StereotypeMetadata tagValueMetadata = stereotypeMetadatasProvider.getStereotype(stereotype).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); + if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated stereotype usage [" + key + "] : " + stereotype); diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/FlatModelExtensionFileParser.java b/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/FlatModelExtensionFileParser.java index bf0682e..7ca8b01 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/FlatModelExtensionFileParser.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/FlatModelExtensionFileParser.java @@ -25,11 +25,12 @@ package org.nuiton.eugene.models.object.reader.extension; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.nuiton.eugene.models.extension.stereotype.InvalidStereotypeSyntaxException; +import org.nuiton.eugene.models.extension.stereotype.StereotypeUtil; +import org.nuiton.eugene.models.extension.tagvalue.InvalidTagValueSyntaxException; +import org.nuiton.eugene.models.extension.tagvalue.TagValueUtil; import org.nuiton.eugene.models.object.reader.InvalidModelPropertiesException; -import org.nuiton.eugene.models.stereotype.InvalidStereotypeSyntaxException; import org.nuiton.eugene.models.stereotype.Stereotypes; -import org.nuiton.eugene.models.tagvalue.InvalidTagValueSyntaxException; -import org.nuiton.eugene.models.tagvalue.TagValues; import org.nuiton.util.RecursiveProperties; import org.nuiton.util.StringUtil; @@ -127,7 +128,7 @@ public class FlatModelExtensionFileParser implements ModelExtensionFileParser { // model tag value if (tagValueTypeKey) { - Matcher matcher = TagValues.getModelMatcher(key); + Matcher matcher = TagValueUtil.getModelMatcher(key); String tag = matcher.group(2); @@ -146,7 +147,7 @@ public class FlatModelExtensionFileParser implements ModelExtensionFileParser { if (stereoTypeKey) { // package stereotype - Matcher matcher = Stereotypes.getPackageMatcher(key); + Matcher matcher = StereotypeUtil.getPackageMatcher(key); String fqn = matcher.group(1); fqn = StringUtil.substring(fqn, 0, -1); // remove ended . @@ -163,7 +164,7 @@ public class FlatModelExtensionFileParser implements ModelExtensionFileParser { // package tag value - Matcher matcher = TagValues.getPackageMatcher(key); + Matcher matcher = TagValueUtil.getPackageMatcher(key); String packageName = matcher.group(1); packageName = StringUtil.substring(packageName, 0, -1); // remove ended . @@ -184,7 +185,7 @@ public class FlatModelExtensionFileParser implements ModelExtensionFileParser { // stereotype property // check key is ok - Matcher matcher = Stereotypes.getMatcher(key); + Matcher matcher = StereotypeUtil.getMatcher(key); String fqn = matcher.group(1); fqn = StringUtil.substring(fqn, 0, -1); // remove ended . @@ -208,7 +209,7 @@ public class FlatModelExtensionFileParser implements ModelExtensionFileParser { // tag value property - Matcher matcher = TagValues.getMatcher(key); + Matcher matcher = TagValueUtil.getMatcher(key); String fqn = matcher.group(1); fqn = StringUtil.substring(fqn, 0, -1); // remove ended dot diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/LoadModelExtension.java b/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/LoadModelExtension.java index 5fb3a80..43a6ca8 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/LoadModelExtension.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/LoadModelExtension.java @@ -24,7 +24,19 @@ package org.nuiton.eugene.models.object.reader.extension; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.nuiton.eugene.EugeneTagValues; +import org.nuiton.eugene.EugeneCoreTagValues; +import org.nuiton.eugene.models.extension.stereotype.InvalidStereotypeSyntaxException; +import org.nuiton.eugene.models.extension.stereotype.MismatchStereotypeTargetException; +import org.nuiton.eugene.models.extension.stereotype.StereotypeMetadata; +import org.nuiton.eugene.models.extension.stereotype.StereotypeNotFoundException; +import org.nuiton.eugene.models.extension.stereotype.provider.AggregateStereotypeMetadatasProvider; +import org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider; +import org.nuiton.eugene.models.extension.tagvalue.InvalidTagValueSyntaxException; +import org.nuiton.eugene.models.extension.tagvalue.MismatchTagValueTargetException; +import org.nuiton.eugene.models.extension.tagvalue.TagValueMetadata; +import org.nuiton.eugene.models.extension.tagvalue.TagValueNotFoundException; +import org.nuiton.eugene.models.extension.tagvalue.provider.AggregateTagValueMetadatasProvider; +import org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider; import org.nuiton.eugene.models.object.ObjectModel; import org.nuiton.eugene.models.object.ObjectModelAssociationClass; import org.nuiton.eugene.models.object.ObjectModelAttribute; @@ -34,16 +46,6 @@ import org.nuiton.eugene.models.object.ObjectModelPackage; import org.nuiton.eugene.models.object.xml.ObjectModelAssociationClassImpl; import org.nuiton.eugene.models.object.xml.ObjectModelClassifierImpl; import org.nuiton.eugene.models.object.xml.ObjectModelImpl; -import org.nuiton.eugene.models.stereotype.InvalidStereotypeSyntaxException; -import org.nuiton.eugene.models.stereotype.MismatchStereotypeTargetException; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProvider; -import org.nuiton.eugene.models.stereotype.StereotypeDefinitionProviders; -import org.nuiton.eugene.models.stereotype.StereotypeNotFoundException; -import org.nuiton.eugene.models.tagvalue.InvalidTagValueSyntaxException; -import org.nuiton.eugene.models.tagvalue.MismatchTagValueTargetException; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProvider; -import org.nuiton.eugene.models.tagvalue.TagValueDefinitionProviders; -import org.nuiton.eugene.models.tagvalue.TagValueNotFoundException; import java.io.File; import java.io.IOException; @@ -62,8 +64,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension protected final boolean verbose; protected final boolean strictLoading; protected final M model; - protected final TagValueDefinitionProvider tagValueDefinitionProvider; - protected final StereotypeDefinitionProvider stereotypeDefinitionProvider; + protected final TagValueMetadatasProvider tagValueMetadatasProvider; + protected final StereotypeMetadatasProvider stereotypeMetadatasProvider; public static <M extends ObjectModel> void loadForFlatModel(boolean verbose, boolean strictLoading, M model, File modelExtension) throws IOException { FlatModelExtensionFileParser parser = new FlatModelExtensionFileParser(strictLoading); @@ -91,8 +93,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension this.verbose = verbose; this.strictLoading = strictLoading; this.model = model; - this.tagValueDefinitionProvider = TagValueDefinitionProviders.newProvider(getClass().getClassLoader(), false); - this.stereotypeDefinitionProvider = StereotypeDefinitionProviders.newProvider(getClass().getClassLoader(), false); + this.tagValueMetadatasProvider = new AggregateTagValueMetadatasProvider(getClass().getClassLoader()); + this.stereotypeMetadatasProvider = new AggregateStereotypeMetadatasProvider(getClass().getClassLoader()); } public void load(File modelExtension) throws IOException, InvalidTagValueSyntaxException, InvalidStereotypeSyntaxException { @@ -108,7 +110,7 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension boolean safe = false; try { - tagValueDefinitionProvider.validate(tag, ObjectModel.class); + tagValueMetadatasProvider.validate(tag, ObjectModel.class); safe = true; } catch (TagValueNotFoundException e) { String message = "Invalid model tag value: the tagvalue '" + tag + "' is unknown."; @@ -129,7 +131,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension if (safe) { // test if tagValue is deprecated - boolean deprecated = tagValueDefinitionProvider.isDeprecated(tag); + TagValueMetadata tagValueMetadata = tagValueMetadatasProvider.getTagValue(tag).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated tagValue usage: " + value); @@ -143,7 +146,7 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension } ObjectModelImpl modelImpl = (ObjectModelImpl) model; - if (tag.equals(EugeneTagValues.TAG_VERSION)) { + if (tag.equals(EugeneCoreTagValues.Store.version.getName())) { // push directly the version in the model version property modelImpl.setVersion(value); @@ -163,7 +166,7 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension boolean safe = false; try { - stereotypeDefinitionProvider.validate(stereotype, ObjectModel.class); + stereotypeMetadatasProvider.validate(stereotype, ObjectModel.class); safe = true; } catch (StereotypeNotFoundException e) { @@ -185,7 +188,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension if (safe) { // test if stereotype is deprecated - boolean deprecated = stereotypeDefinitionProvider.isDeprecated(stereotype); + StereotypeMetadata tagValueMetadata = stereotypeMetadatasProvider.getStereotype(stereotype).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { log.warn("Deprecated model stereotype usage: " + stereotype); } @@ -208,7 +212,7 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension boolean safe = false; try { - tagValueDefinitionProvider.validate(tag, ObjectModelPackage.class); + tagValueMetadatasProvider.validate(tag, ObjectModelPackage.class); safe = true; } catch (TagValueNotFoundException e) { String message = "Invalid tag value on package [" + packageName + "]: the tagvalue '" + tag + "' is unknown."; @@ -230,7 +234,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension if (safe) { // test if tagValue is deprecated - boolean deprecated = tagValueDefinitionProvider.isDeprecated(tag); + TagValueMetadata tagValueMetadata = tagValueMetadatasProvider.getTagValue(tag).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated tagValue usage on package [" + packageName + "]: " + value); @@ -256,7 +261,7 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension boolean safe = false; try { - stereotypeDefinitionProvider.validate(stereotype, ObjectModelPackage.class); + stereotypeMetadatasProvider.validate(stereotype, ObjectModelPackage.class); safe = true; } catch (StereotypeNotFoundException e) { String message = "Invalid model stereotype on package [" + packageName + "]: the stereotype '" + stereotype + "' is unknown."; @@ -277,7 +282,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension if (safe) { // test if tagValue is deprecated - boolean deprecated = stereotypeDefinitionProvider.isDeprecated(stereotype); + StereotypeMetadata tagValueMetadata = stereotypeMetadatasProvider.getStereotype(stereotype).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { log.warn("Deprecated stereotype usage on package [" + packageName + "]: " + stereotype); } @@ -310,7 +316,7 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension boolean safe = false; try { - tagValueDefinitionProvider.validate(tag, ObjectModelClass.class); + tagValueMetadatasProvider.validate(tag, ObjectModelClass.class); safe = true; } catch (TagValueNotFoundException e) { @@ -333,7 +339,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension if (safe) { // test if tagValue is deprecated - boolean deprecated = tagValueDefinitionProvider.isDeprecated(tag); + TagValueMetadata tagValueMetadata = tagValueMetadatasProvider.getTagValue(tag).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated tagValue usage on class [" + className + "] : " + value); @@ -368,7 +375,7 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension boolean safe = false; try { - stereotypeDefinitionProvider.validate(stereotype, ObjectModelClassifier.class); + stereotypeMetadatasProvider.validate(stereotype, ObjectModelClassifier.class); safe = true; } catch (StereotypeNotFoundException e) { @@ -390,7 +397,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension if (safe) { // test if stereotype is deprecated - boolean deprecated = stereotypeDefinitionProvider.isDeprecated(stereotype); + StereotypeMetadata tagValueMetadata = stereotypeMetadatasProvider.getStereotype(stereotype).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated stereotype usage on class [" + className + "]: " + stereotype); @@ -424,7 +432,7 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension boolean safe = false; try { - tagValueDefinitionProvider.validate(tag, ObjectModelAttribute.class); + tagValueMetadatasProvider.validate(tag, ObjectModelAttribute.class); safe = true; } catch (TagValueNotFoundException e) { @@ -447,7 +455,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension if (safe) { // test if tagValue is deprecated - boolean deprecated = tagValueDefinitionProvider.isDeprecated(tag); + TagValueMetadata tagValueMetadata = tagValueMetadatasProvider.getTagValue(tag).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { if (log.isWarnEnabled()) { log.warn("Deprecated tagValue usage on attribute [" + className + "#" + attributeName + "] : " + value); @@ -489,7 +498,7 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension boolean safe = false; try { - stereotypeDefinitionProvider.validate(stereotype, ObjectModelAttribute.class); + stereotypeMetadatasProvider.validate(stereotype, ObjectModelAttribute.class); safe = true; } catch (StereotypeNotFoundException e) { @@ -511,7 +520,8 @@ public class LoadModelExtension<M extends ObjectModel> implements ModelExtension if (safe) { // test if stereotype is deprecated - boolean deprecated = stereotypeDefinitionProvider.isDeprecated(stereotype); + StereotypeMetadata tagValueMetadata = stereotypeMetadatasProvider.getStereotype(stereotype).get(); + boolean deprecated = tagValueMetadata.isDeprecated(); if (deprecated) { log.warn("Deprecated stereotype usage on attribute [" + className + "]: " + stereotype); } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/ModelExtensionFileParser.java b/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/ModelExtensionFileParser.java index 42165b1..9ab5866 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/ModelExtensionFileParser.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/reader/extension/ModelExtensionFileParser.java @@ -22,8 +22,9 @@ package org.nuiton.eugene.models.object.reader.extension; * #L% */ -import org.nuiton.eugene.models.stereotype.InvalidStereotypeSyntaxException; -import org.nuiton.eugene.models.tagvalue.InvalidTagValueSyntaxException; + +import org.nuiton.eugene.models.extension.stereotype.InvalidStereotypeSyntaxException; +import org.nuiton.eugene.models.extension.tagvalue.InvalidTagValueSyntaxException; import java.io.File; import java.io.IOException; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelAttributeImpl.java b/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelAttributeImpl.java index 6c0ef06..417338b 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelAttributeImpl.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelAttributeImpl.java @@ -26,7 +26,7 @@ import com.google.common.collect.ImmutableSet; import com.google.common.collect.Iterables; import com.google.common.collect.Sets; import org.apache.commons.lang3.StringUtils; -import org.nuiton.eugene.EugeneStereoTypes; +import org.nuiton.eugene.EugeneCoreStereotypes; import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.models.object.ObjectModelAttribute; import org.nuiton.eugene.models.object.ObjectModelClass; @@ -298,7 +298,7 @@ public class ObjectModelAttributeImpl extends ObjectModelParameterImpl @Override public ObjectModelImplRef addStereotype(ObjectModelImplRef stereotype) { String stereotypeName = stereotype.getName(); - if (EugeneStereoTypes.STEREOTYPE_ORDERED.equals(stereotypeName)) { + if (EugeneCoreStereotypes.Store.ordered.getName().equals(stereotypeName)) { setOrdered(true); } return super.addStereotype(stereotype); diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelElementImpl.java b/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelElementImpl.java index 933a90c..d35e606 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelElementImpl.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelElementImpl.java @@ -26,7 +26,7 @@ import com.google.common.collect.Iterables; import org.apache.commons.lang3.StringUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.nuiton.eugene.EugeneTagValues; +import org.nuiton.eugene.EugeneCoreTagValues; import org.nuiton.eugene.models.object.ObjectModelElement; import org.nuiton.eugene.models.object.ObjectModelJavaModifier; import org.nuiton.eugene.models.object.ObjectModelModifier; @@ -176,8 +176,8 @@ public abstract class ObjectModelElementImpl implements ObjectModelElement { @Override public String getDocumentation() { - if (documentation == null && hasTagValue(EugeneTagValues.TAG_DOCUMENTATION)) { - String doc = getTagValue(EugeneTagValues.TAG_DOCUMENTATION); + if (documentation == null && hasTagValue(EugeneCoreTagValues.Store.documentation.getName())) { + String doc = getTagValue(EugeneCoreTagValues.Store.documentation.getName()); if (StringUtils.isNotEmpty(doc)) { documentation = doc; } @@ -211,6 +211,11 @@ public abstract class ObjectModelElementImpl implements ObjectModelElement { } @Override + public void removeStereotype(String stereotype) { + stereotypes.remove(stereotype); + } + + @Override public Map<String, String> getTagValues() { return tagValues; } @@ -226,6 +231,11 @@ public abstract class ObjectModelElementImpl implements ObjectModelElement { } @Override + public void removeTagValue(String tagvalue) { + tagValues.remove(tagvalue); + } + + @Override public void addTagValue(String tagValue, String value) { String oldValue = getTagValue(tagValue); if (StringUtils.isNotEmpty(oldValue)) { diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelImpl.java b/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelImpl.java index 9a58dfa..425cd6f 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelImpl.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelImpl.java @@ -39,6 +39,7 @@ import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -396,6 +397,46 @@ public class ObjectModelImpl implements ObjectModel { stereotypes.add(stereotype); } + @Override + public void removeStereotype(String stereotype) { + stereotypes.remove(stereotype); + } + + public void removePackage(String packageName) { + + for (ObjectModelClass objectModelClass : new LinkedHashSet<>(classes.values()) ) { + if (objectModelClass.getQualifiedName().startsWith(packageName+".")) { + classes.remove(objectModelClass.getQualifiedName()); + } + } + for (ObjectModelInterface objectModelInterface : new LinkedHashSet<>(interfaces.values()) ) { + if (objectModelInterface.getQualifiedName().startsWith(packageName+".")) { + classes.remove(objectModelInterface.getQualifiedName()); + } + } + for (ObjectModelEnumeration objectModelEnumeration : new LinkedHashSet<>(enumerations.values()) ) { + if (objectModelEnumeration.getQualifiedName().startsWith(packageName+".")) { + classes.remove(objectModelEnumeration.getQualifiedName()); + } + } + packages.remove(packageName); + + } + + public void removeClass(String className) { + + classes.remove(className); + + } + + public void removeInterface(String interfaceName) { + interfaces.remove(interfaceName); + } + + public void removeEnumeration(String enumerationName) { + enumerations.remove(enumerationName); + } + protected void mergePackages( ObjectModelPackageImpl initialPackage, ObjectModelPackageImpl additionalPackage) { @@ -639,6 +680,11 @@ public class ObjectModelImpl implements ObjectModel { return tagValues.containsKey(tagValue); } + @Override + public void removeTagValue(String tagvalue) { + tagValues.remove(tagvalue); + } + /** * Get the extension associated to the reference (unique). Create it if not exist. * diff --git a/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelPackageImpl.java b/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelPackageImpl.java index a6a11da..16dfe5f 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelPackageImpl.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelPackageImpl.java @@ -111,6 +111,11 @@ public class ObjectModelPackageImpl implements ObjectModelPackage { } @Override + public void removeStereotype(String stereotype) { + stereotypes.remove(stereotype); + } + + @Override public Map<String, String> getTagValues() { return tagValues; } @@ -139,6 +144,11 @@ public class ObjectModelPackageImpl implements ObjectModelPackage { } @Override + public void removeTagValue(String tagvalue) { + tagValues.remove(tagvalue); + } + + @Override public List<String> getComments() { return comments; } diff --git a/eugene/src/main/java/org/nuiton/eugene/models/state/xml/StateModelImpl.java b/eugene/src/main/java/org/nuiton/eugene/models/state/xml/StateModelImpl.java index f45a87d..ddabd63 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/state/xml/StateModelImpl.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/state/xml/StateModelImpl.java @@ -103,6 +103,11 @@ public class StateModelImpl implements StateModel { stereotypes.add(stereotype); } + @Override + public void removeStereotype(String stereotype) { + stereotypes.remove(stereotype); + } + /** * Set model name. * @@ -161,6 +166,11 @@ public class StateModelImpl implements StateModel { return modelTagValues.containsKey(tagValue); } + @Override + public void removeTagValue(String tagvalue) { + modelTagValues.remove(tagvalue); + } + /** * Set model version. * diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/AggregateStereotypeDefinitionProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/AggregateStereotypeDefinitionProvider.java index 9335cdf..44463c0 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/AggregateStereotypeDefinitionProvider.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/AggregateStereotypeDefinitionProvider.java @@ -34,6 +34,7 @@ import java.util.ServiceLoader; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class AggregateStereotypeDefinitionProvider extends StereotypeDefinitionProvider implements Iterable<StereotypeDefinitionProvider> { /** Logger. */ diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/InvalidStereotypeSyntaxException.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/InvalidStereotypeSyntaxException.java index f751d4e..a4dfde5 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/InvalidStereotypeSyntaxException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/InvalidStereotypeSyntaxException.java @@ -28,6 +28,7 @@ package org.nuiton.eugene.models.stereotype; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class InvalidStereotypeSyntaxException extends Exception { private static final long serialVersionUID = 1L; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MismatchStereotypeTargetException.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MismatchStereotypeTargetException.java index f62b9bc..25226a4 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MismatchStereotypeTargetException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MismatchStereotypeTargetException.java @@ -28,6 +28,7 @@ package org.nuiton.eugene.models.stereotype; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class MismatchStereotypeTargetException extends Exception { private static final long serialVersionUID = 1L; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MissingStereoTypeException.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MissingStereoTypeException.java index 1b29142..8c54a44 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MissingStereoTypeException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MissingStereoTypeException.java @@ -36,6 +36,7 @@ import java.util.Set; * @author Tony Chemit - chemit@codelutin.com * @since 3.0 */ +@Deprecated public class MissingStereoTypeException extends RuntimeException { private static final long serialVersionUID = 1L; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MyStereotypeDefinitionProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MyStereotypeDefinitionProvider.java index c25195e..b713d5f 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MyStereotypeDefinitionProvider.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/MyStereotypeDefinitionProvider.java @@ -30,6 +30,7 @@ import org.nuiton.eugene.models.object.ObjectModelAttribute; * @author Tony Chemit - chemit@codelutin.com * @since XXX */ +@Deprecated public class MyStereotypeDefinitionProvider extends StereotypeDefinitionProvider { @StereotypeDefinition(target = ObjectModelAttribute.class, diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeAble.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeAble.java index c9b4744..741879c 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeAble.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeAble.java @@ -30,6 +30,7 @@ import java.util.Set; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public interface StereotypeAble { /** diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinition.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinition.java index 2f94f27..b5ddafb 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinition.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinition.java @@ -46,6 +46,7 @@ import java.lang.annotation.Target; */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) +@Deprecated public @interface StereotypeDefinition { /** diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProvider.java index 0920cec..97a3681 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProvider.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProvider.java @@ -61,6 +61,7 @@ import java.util.TreeMap; * @see EugeneStereoTypes * @since 2.9 */ +@Deprecated public class StereotypeDefinitionProvider { /** Logger. */ diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProviderManagerExtension.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProviderManagerExtension.java index e4f899b..f700af1 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProviderManagerExtension.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProviderManagerExtension.java @@ -30,6 +30,7 @@ import com.google.common.base.Preconditions; * @author Tony Chemit - chemit@codelutin.com * @since 2.11 */ +@Deprecated public class StereotypeDefinitionProviderManagerExtension { /** diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProviders.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProviders.java index 3d13f8a..4ae281b 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProviders.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeDefinitionProviders.java @@ -31,6 +31,7 @@ import org.apache.commons.logging.LogFactory; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class StereotypeDefinitionProviders { /** Logger. */ diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeNotFoundException.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeNotFoundException.java index f5d9a89..d06b588 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeNotFoundException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/StereotypeNotFoundException.java @@ -28,6 +28,7 @@ package org.nuiton.eugene.models.stereotype; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class StereotypeNotFoundException extends Exception { private static final long serialVersionUID = 1L; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/Stereotypes.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/Stereotypes.java index 2bc9553..60c0f6b 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/Stereotypes.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/Stereotypes.java @@ -38,6 +38,7 @@ import java.util.regex.Pattern; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class Stereotypes { protected static final Pattern PACKAGE_STEREOTYPE_PATTERN = Pattern diff --git a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/package-info.java b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/package-info.java index 88f6c0a..a9be001 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/stereotype/package-info.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/stereotype/package-info.java @@ -27,5 +27,6 @@ * * @since 2.9 */ +@Deprecated package org.nuiton.eugene.models.stereotype; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/AggregateTagValueDefinitionProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/AggregateTagValueDefinitionProvider.java index 64c93a6..d7ed33c 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/AggregateTagValueDefinitionProvider.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/AggregateTagValueDefinitionProvider.java @@ -34,6 +34,7 @@ import java.util.ServiceLoader; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class AggregateTagValueDefinitionProvider extends TagValueDefinitionProvider implements Iterable<TagValueDefinitionProvider> { /** Logger. */ diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/InvalidTagValueSyntaxException.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/InvalidTagValueSyntaxException.java index 7585d91..2335218 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/InvalidTagValueSyntaxException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/InvalidTagValueSyntaxException.java @@ -28,6 +28,7 @@ package org.nuiton.eugene.models.tagvalue; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class InvalidTagValueSyntaxException extends Exception { private static final long serialVersionUID = 1L; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MismatchTagValueTargetException.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MismatchTagValueTargetException.java index 9c2570f..526b671 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MismatchTagValueTargetException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MismatchTagValueTargetException.java @@ -28,6 +28,7 @@ package org.nuiton.eugene.models.tagvalue; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class MismatchTagValueTargetException extends Exception { private static final long serialVersionUID = 1L; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MissingTagValueException.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MissingTagValueException.java index fbf0369..00a17fd 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MissingTagValueException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/MissingTagValueException.java @@ -36,6 +36,7 @@ import java.util.Set; * @author Tony Chemit - chemit@codelutin.com * @since 3.0 */ +@Deprecated public class MissingTagValueException extends RuntimeException { private static final long serialVersionUID = 1L; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueAble.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueAble.java index 734e532..0a71892 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueAble.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueAble.java @@ -30,6 +30,7 @@ import java.util.Map; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public interface TagValueAble { /** diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinition.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinition.java index d54a9c1..7255ee1 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinition.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinition.java @@ -47,6 +47,7 @@ import java.lang.annotation.Target; */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) +@Deprecated public @interface TagValueDefinition { /** diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProvider.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProvider.java index 7778b60..2d9284f 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProvider.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProvider.java @@ -65,6 +65,7 @@ import java.util.TreeMap; * @see EugeneTagValues * @since 2.9 */ +@Deprecated public class TagValueDefinitionProvider { /** Logger. */ diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProviderManagerExtension.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProviderManagerExtension.java index 4c9f04d..8817e8d 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProviderManagerExtension.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProviderManagerExtension.java @@ -30,6 +30,7 @@ import com.google.common.base.Preconditions; * @author Tony Chemit - chemit@codelutin.com * @since 2.11 */ +@Deprecated public class TagValueDefinitionProviderManagerExtension { /** diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProviders.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProviders.java index f834c82..efcb304 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProviders.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueDefinitionProviders.java @@ -31,6 +31,7 @@ import org.apache.commons.logging.LogFactory; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class TagValueDefinitionProviders { /** Logger. */ diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueNotFoundException.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueNotFoundException.java index 118267f..7480ae6 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueNotFoundException.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValueNotFoundException.java @@ -28,6 +28,7 @@ package org.nuiton.eugene.models.tagvalue; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class TagValueNotFoundException extends Exception { private static final long serialVersionUID = 1L; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValues.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValues.java index c64af9c..31e39b7 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValues.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/TagValues.java @@ -38,6 +38,7 @@ import java.util.regex.Pattern; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class TagValues { /** diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/EqualsTagValueNameMatcher.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/EqualsTagValueNameMatcher.java index b6fe7a7..82c7083 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/EqualsTagValueNameMatcher.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/EqualsTagValueNameMatcher.java @@ -32,6 +32,7 @@ import java.util.Map; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class EqualsTagValueNameMatcher extends TagValueDefinitionMatcher { public EqualsTagValueNameMatcher(Map<String, TagValueDefinition> tagValueDefinitionMap) { diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/StartsWithTagNameMatcher.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/StartsWithTagNameMatcher.java index 24b0643..2c30604 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/StartsWithTagNameMatcher.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/StartsWithTagNameMatcher.java @@ -32,6 +32,7 @@ import java.util.Map; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public class StartsWithTagNameMatcher extends TagValueDefinitionMatcher { public StartsWithTagNameMatcher(Map<String, TagValueDefinition> tagValueDefinitionMap) { diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/TagValueDefinitionMatcher.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/TagValueDefinitionMatcher.java index c899ce6..b765962 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/TagValueDefinitionMatcher.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/matcher/TagValueDefinitionMatcher.java @@ -35,6 +35,7 @@ import java.util.Map; * @author Tony Chemit - chemit@codelutin.com * @since 2.9 */ +@Deprecated public abstract class TagValueDefinitionMatcher { protected Map<String, TagValueDefinition> tagValueDefinitionMap; diff --git a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/package-info.java b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/package-info.java index 99b209f..ae63624 100644 --- a/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/package-info.java +++ b/eugene/src/main/java/org/nuiton/eugene/models/tagvalue/package-info.java @@ -27,5 +27,6 @@ * * @since 2.9 */ +@Deprecated package org.nuiton.eugene.models.tagvalue; diff --git a/eugene/src/main/resolver-cache/META-INF/services/org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider b/eugene/src/main/resolver-cache/META-INF/services/org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider new file mode 100644 index 0000000..c5380f2 --- /dev/null +++ b/eugene/src/main/resolver-cache/META-INF/services/org.nuiton.eugene.models.extension.stereotype.provider.StereotypeMetadatasProvider @@ -0,0 +1 @@ +org.nuiton.eugene.EugeneCoreStereotypes \ No newline at end of file diff --git a/eugene/src/main/resolver-cache/META-INF/services/org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider b/eugene/src/main/resolver-cache/META-INF/services/org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider new file mode 100644 index 0000000..aa68615 --- /dev/null +++ b/eugene/src/main/resolver-cache/META-INF/services/org.nuiton.eugene.models.extension.tagvalue.provider.TagValueMetadatasProvider @@ -0,0 +1 @@ +org.nuiton.eugene.EugeneCoreTagValues \ No newline at end of file diff --git a/eugene/src/test/java/org/nuiton/eugene/EugeneCoreStereotypesTest.java b/eugene/src/test/java/org/nuiton/eugene/EugeneCoreStereotypesTest.java new file mode 100644 index 0000000..fa1af5a --- /dev/null +++ b/eugene/src/test/java/org/nuiton/eugene/EugeneCoreStereotypesTest.java @@ -0,0 +1,52 @@ +package org.nuiton.eugene; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.nuiton.eugene.models.extension.stereotype.MismatchStereotypeTargetException; +import org.nuiton.eugene.models.extension.stereotype.StereotypeNotFoundException; +import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelEnumeration; +import org.nuiton.eugene.models.object.ObjectModelInterface; +import org.nuiton.eugene.models.object.ObjectModelOperation; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class EugeneCoreStereotypesTest { + + protected EugeneCoreStereotypes provider; + + @Before + public void setUp() throws Exception { + provider = new EugeneCoreStereotypes(); + } + + @Test + public void validate() throws Exception { + + validate(EugeneCoreStereotypes.Store.ordered.name(), true, ObjectModelAttribute.class); + + validate(EugeneCoreStereotypes.Store.ordered.name(), false, ObjectModel.class, ObjectModelOperation.class, ObjectModelClassifier.class, ObjectModelClass.class, ObjectModelEnumeration.class, ObjectModelInterface.class); + + long l = System.nanoTime(); + validate(EugeneCoreStereotypes.Store.ordered.name() + l, false, ObjectModel.class, ObjectModelOperation.class, ObjectModelClassifier.class, ObjectModelClass.class, ObjectModelEnumeration.class, ObjectModelInterface.class); + + } + + protected void validate(String name, boolean expected, Class<?>... types) { + for (Class<?> type : types) { + try { + provider.validate(name, type); + Assert.assertTrue(expected); + } catch (StereotypeNotFoundException | MismatchStereotypeTargetException e) { + Assert.assertFalse(expected); + } + } + } +} diff --git a/eugene/src/test/java/org/nuiton/eugene/EugeneCoreTagValuesTest.java b/eugene/src/test/java/org/nuiton/eugene/EugeneCoreTagValuesTest.java new file mode 100644 index 0000000..d694981 --- /dev/null +++ b/eugene/src/test/java/org/nuiton/eugene/EugeneCoreTagValuesTest.java @@ -0,0 +1,68 @@ +package org.nuiton.eugene; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.nuiton.eugene.models.extension.tagvalue.MismatchTagValueTargetException; +import org.nuiton.eugene.models.extension.tagvalue.TagValueNotFoundException; +import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelEnumeration; +import org.nuiton.eugene.models.object.ObjectModelOperation; +import org.nuiton.eugene.models.object.ObjectModelPackage; +import org.nuiton.eugene.models.object.xml.ObjectModelClassImpl; +import org.nuiton.eugene.models.object.xml.ObjectModelImpl; +import org.nuiton.eugene.models.object.xml.ObjectModelPackageImpl; + +/** + * Created on 24/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class EugeneCoreTagValuesTest { + + protected EugeneCoreTagValues provider; + + @Before + public void setUp() throws Exception { + provider = new EugeneCoreTagValues(); + } + + @Test + public void validate() throws Exception { + validate(EugeneCoreTagValues.Store.constantPrefix.getName(), true, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class, ObjectModelClass.class, ObjectModelEnumeration.class); + validate(EugeneCoreTagValues.Store.i18n.getName(), true, ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class, ObjectModelClass.class, ObjectModelEnumeration.class); + validate(EugeneCoreTagValues.Store.version.getName(), true, ObjectModel.class); + + validate(EugeneCoreTagValues.Store.constantPrefix.getName(), false, ObjectModelOperation.class, ObjectModelAttribute.class); + validate(EugeneCoreTagValues.Store.i18n.getName(), false, ObjectModelOperation.class, ObjectModelAttribute.class); + validate(EugeneCoreTagValues.Store.version.getName(), false, ObjectModelPackage.class, ObjectModelClassifier.class, ObjectModelOperation.class, ObjectModelAttribute.class); + + long l = System.nanoTime(); + validate(EugeneCoreTagValues.Store.constantPrefix.getName() + l, false, ObjectModelOperation.class, ObjectModelPackage.class, ObjectModelAttribute.class); + validate(EugeneCoreTagValues.Store.i18n.getName() + l, false, ObjectModelOperation.class, ObjectModelPackage.class, ObjectModelAttribute.class); + validate(EugeneCoreTagValues.Store.version.getName() + l, false, ObjectModelClassifier.class, ObjectModelPackage.class, ObjectModelOperation.class, ObjectModelAttribute.class); + } + + @Test + public void testDefaultValue() throws Exception { + Assert.assertEquals("PROPERTY_", provider.getConstantPrefixTagValue(new ObjectModelClassImpl(), new ObjectModelPackageImpl(), new ObjectModelImpl())); + Assert.assertEquals(false, provider.isGenerateBooleanGetMethods(new ObjectModelClassImpl(), new ObjectModelPackageImpl(), new ObjectModelImpl())); + // No default value + Assert.assertNull(provider.getI18nPrefixTagValue(new ObjectModelClassImpl(), new ObjectModelPackageImpl(), new ObjectModelImpl())); + } + + protected void validate(String name, boolean expected, Class<?>... types) { + for (Class<?> type : types) { + + try { + provider.validate(name, type); + Assert.assertTrue(expected); + } catch (TagValueNotFoundException | MismatchTagValueTargetException e) { + Assert.assertFalse(expected); + } + } + } +} \ No newline at end of file diff --git a/eugene/src/test/java/org/nuiton/eugene/models/object/XMI21ToObjectModelTest.java b/eugene/src/test/java/org/nuiton/eugene/models/object/XMI21ToObjectModelTest.java index ff87c25..73dddc2 100644 --- a/eugene/src/test/java/org/nuiton/eugene/models/object/XMI21ToObjectModelTest.java +++ b/eugene/src/test/java/org/nuiton/eugene/models/object/XMI21ToObjectModelTest.java @@ -25,7 +25,7 @@ package org.nuiton.eugene.models.object; import org.junit.BeforeClass; import org.junit.Ignore; import org.junit.Test; -import org.nuiton.eugene.EugeneTagValues; +import org.nuiton.eugene.EugeneCoreTagValues; import org.nuiton.eugene.TestHelper; import org.nuiton.eugene.models.object.reader.XmlObjectModelReader; import org.nuiton.util.FileUtil; @@ -541,8 +541,7 @@ public class XMI21ToObjectModelTest { public void testTestXMI21Documentation() throws URISyntaxException, IOException, TransformerException { - EugeneTagValues eugeneTagValues = new EugeneTagValues(); - eugeneTagValues.init(); + EugeneCoreTagValues eugeneTagValues = new EugeneCoreTagValues(); ObjectModel model = xmiToObjectModel("TestXMI21"); -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.