diff --git a/dumpAst.base/src/main/jastadd/DumpAst.relast b/dumpAst.base/src/main/jastadd/DumpAst.relast index 0a8c621ac87bb5aaa992c8ea2f53cd194aef4cee..f66e04b7aca3b740004a7fc24dea2584a19945f9 100644 --- a/dumpAst.base/src/main/jastadd/DumpAst.relast +++ b/dumpAst.base/src/main/jastadd/DumpAst.relast @@ -54,9 +54,6 @@ IntrinsicTokenMethod : TokenMethod ::= <Refined:boolean> ; AttributeMethod : TokenMethod ; BuildConfig ::= StyleInformation - GlobalPatternCollection:PatternCollection - ExcludeTypePattern:TypePatternCollectionMapping* - IncludeTypePattern:TypePatternCollectionMapping* <IncludeRelationMethod:IncludeRelationMethod> <IncludeChildMethod:IncludeChildMethod> <IncludeAttributeMethod:IncludeAttributeMethod> @@ -65,8 +62,6 @@ BuildConfig ::= StyleInformation <IncludeEmptyString:boolean> <ExcludeNullNodes:boolean> <Debug:boolean>; -TypePatternCollectionMapping ::= <TypeRegex> PatternCollection ; -PatternCollection ::= <TokenPattern> <ChildPattern> <RelationPattern> <AttributePattern> <NonterminalAttributePattern> ; StyleInformation ::= <ComputedColor>; PrintConfig ::= Header* diff --git a/dumpAst.base/src/main/java/de/tudresden/inf/st/jastadd/dumpAst/ast/DumpBuilder.java b/dumpAst.base/src/main/java/de/tudresden/inf/st/jastadd/dumpAst/ast/DumpBuilder.java index 6644961f6b73441e21a8b218e5d00c05134c658d..e3a7265fb4948038735661681fab2edc67a8fd31 100644 --- a/dumpAst.base/src/main/java/de/tudresden/inf/st/jastadd/dumpAst/ast/DumpBuilder.java +++ b/dumpAst.base/src/main/java/de/tudresden/inf/st/jastadd/dumpAst/ast/DumpBuilder.java @@ -5,6 +5,7 @@ import net.sourceforge.plantuml.FileFormatOption; import net.sourceforge.plantuml.SourceStringReader; import java.io.IOException; +import java.io.OutputStream; import java.io.Writer; import java.lang.reflect.InvocationTargetException; import java.nio.file.Files; @@ -13,8 +14,6 @@ import java.util.ResourceBundle; import java.util.function.Consumer; import java.util.function.Supplier; -import static de.tudresden.inf.st.jastadd.dumpAst.ast.ASTNode.matches; - /** * Creating a snapshot of an AST. */ @@ -31,68 +30,10 @@ public class DumpBuilder { this.built = false; this.dumpAst = new DumpAst(); dumpAst.setBuildConfig(new BuildConfig()); - dumpAst.getBuildConfig().setIncludeChildMethod((parentNode, childNode, contextName) -> { - // level 4: excluded for type? -> return no - PatternCollection excludeOnType = dumpAst.getBuildConfig().matchExcludePatternCollection(parentNode.getClass().getSimpleName()); - if (excludeOnType != null && matches(excludeOnType.childPattern(), contextName)) { - return false; - } - // level 3: included for type? -> return yes - PatternCollection includeOnType = dumpAst.getBuildConfig().matchIncludePatternCollection(parentNode.getClass().getSimpleName()); - if (includeOnType != null && matches(includeOnType.childPattern(), contextName)) { - return true; - } - // level 2: globally excluded? -> return no - // level 1: otherwise return yes - return !matches(dumpAst.getBuildConfig().getGlobalPatternCollection().childPattern(), contextName); - }); - dumpAst.getBuildConfig().setIncludeRelationMethod((sourceNode, targetNode, roleName) -> { - // level 4: excluded for type? -> return no - PatternCollection excludeOnType = dumpAst.getBuildConfig().matchExcludePatternCollection(sourceNode.getClass().getSimpleName()); - if (excludeOnType != null && matches(excludeOnType.relationPattern(), roleName)) { - return false; - } - // level 3: included for type? -> return yes - PatternCollection includeOnType = dumpAst.getBuildConfig().matchIncludePatternCollection(sourceNode.getClass().getSimpleName()); - if (includeOnType != null && matches(includeOnType.relationPattern(), roleName)) { - return true; - } - // level 2: globally excluded? -> return no - // level 1: otherwise return yes - return !matches(dumpAst.getBuildConfig().getGlobalPatternCollection().relationPattern(), roleName); - }); - dumpAst.getBuildConfig().setIncludeTokenMethod((node, tokenName, value) -> { - // level 4: excluded for type? -> return no - PatternCollection excludeOnType = dumpAst.getBuildConfig().matchExcludePatternCollection(node.getClass().getSimpleName()); - if (excludeOnType != null && matches(excludeOnType.tokenPattern(), tokenName)) { - return false; - } - // level 3: included for type? -> return yes - PatternCollection includeOnType = dumpAst.getBuildConfig().matchIncludePatternCollection(node.getClass().getSimpleName()); - if (includeOnType != null && matches(includeOnType.tokenPattern(), tokenName)) { - return true; - } - // level 2: globally excluded? -> return no - // level 1: otherwise return yes - return !matches(dumpAst.getBuildConfig().getGlobalPatternCollection().tokenPattern(), tokenName); - }); - dumpAst.getBuildConfig().setIncludeAttributeMethod((node, attributeName, isNTA, supplier) -> { - // level 4: included for type? -> return yes - PatternCollection includeOnType = dumpAst.getBuildConfig().matchIncludePatternCollection(node.getClass().getSimpleName()); - if (includeOnType != null && matches(isNTA ? includeOnType.ntaPattern() : includeOnType.attributePattern(), attributeName)) { - return true; - } - // level 3: excluded for type? -> return no - PatternCollection excludeOnType = dumpAst.getBuildConfig().matchExcludePatternCollection(node.getClass().getSimpleName()); - if (excludeOnType != null && matches(isNTA ? excludeOnType.ntaPattern() : excludeOnType.attributePattern(), attributeName)) { - return false; - } - // level 2: globally included? -> return yes - // level 1: otherwise return no - PatternCollection global = dumpAst.getBuildConfig().getGlobalPatternCollection(); - return matches(isNTA ? global.ntaPattern() : global.attributePattern(), attributeName); - }); - dumpAst.getBuildConfig().setGlobalPatternCollection(new PatternCollection()); + dumpAst.getBuildConfig().setIncludeChildMethod((parentNode, childNode, contextName) -> true); + dumpAst.getBuildConfig().setIncludeRelationMethod((sourceNode, targetNode, roleName) -> true); + dumpAst.getBuildConfig().setIncludeTokenMethod((node, tokenName, value) -> true); + dumpAst.getBuildConfig().setIncludeAttributeMethod((node, attributeName, isNTA, supplier) -> false); dumpAst.getBuildConfig().setStyleInformation(StyleInformation.createDefault()); dumpAst.setPrintConfig(new PrintConfig()); dumpAst.getPrintConfig().setScale(1); @@ -168,354 +109,29 @@ public class DumpBuilder { // --- Tokens --- - public <ASTNODE> DumpBuilder includeTokensWhen(IncludeTokenMethod<ASTNODE> spec) { + public <ASTNODE> DumpBuilder includeToken(IncludeTokenMethod<ASTNODE> spec) { dumpAst.getBuildConfig().setIncludeTokenMethod(spec); - if (!dumpAst.getBuildConfig().getGlobalPatternCollection().getTokenPattern().isEmpty()) { - System.err.println("Overriding previous filters for tokens"); - } - return thisWithResetBuilt(); - } - - /** - * Exclude tokens and their value if the token name matches at least one of the given regex strings. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param regex first pattern to match token names - * @param moreRegexes more patterns to match token names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder excludeTokens(String regex, String... moreRegexes) { - updateRegexes(() -> dumpAst.getBuildConfig().getGlobalPatternCollection().getTokenPattern(), - s -> dumpAst.getBuildConfig().getGlobalPatternCollection().setTokenPattern(s), - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Exclude tokens and their value within a type if the token name matches at least one of the given regex strings. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match token names - * @param moreRegexes more patterns to match token names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder excludeTokensFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateExcludePatternCollection(typeRegex); - updateRegexes(collection::getTokenPattern, - collection::setTokenPattern, - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Include tokens (again) and their value within a type if the token name matches at least one of the given regex strings. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match token names - * @param moreRegexes more patterns to match token names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder includeTokensFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateIncludePatternCollection(typeRegex); - updateRegexes(collection::getTokenPattern, - collection::setTokenPattern, - regex, moreRegexes); return thisWithResetBuilt(); } // --- Children --- - public <ASTNODE> DumpBuilder includeChildWhen(IncludeChildMethod<ASTNODE> spec) { + public <ASTNODE> DumpBuilder includeChild(IncludeChildMethod<ASTNODE> spec) { dumpAst.getBuildConfig().setIncludeChildMethod(spec); - if (!dumpAst.getBuildConfig().getGlobalPatternCollection().getChildPattern().isEmpty()) { - System.err.println("Overriding previous filters for children"); - } - return thisWithResetBuilt(); - } - - /** - * Exclude every child whose name (i.e., context) matches at least on of the given regex strings. - * This means, that the complete object and its (transitive) children will never be included in any output. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param regex first pattern to match child name - * @param moreRegexes more patterns to match child names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder excludeChildren(String regex, String... moreRegexes) { - updateRegexes(() -> dumpAst.getBuildConfig().getGlobalPatternCollection().getChildPattern(), - s -> dumpAst.getBuildConfig().getGlobalPatternCollection().setChildPattern(s), - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Exclude every child within a type whose name (i.e., context) matches at least on of the given regex strings. - * This means, that the complete object and its (transitive) children will never be included in any output. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match child name - * @param moreRegexes more patterns to match child names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder excludeChildrenFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateExcludePatternCollection(typeRegex); - updateRegexes(collection::getChildPattern, - collection::setChildPattern, - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Include every child (again) within a type whose name (i.e., context) matches at least on of the given regex strings. - * This means, that the complete object and its (transitive) children will never be included in any output. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match child name - * @param moreRegexes more patterns to match child names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder includeChildrenFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateIncludePatternCollection(typeRegex); - updateRegexes(collection::getChildPattern, - collection::setChildPattern, - regex, moreRegexes); return thisWithResetBuilt(); } // --- Attributes --- - public <ASTNODE> DumpBuilder includeAttributeWhen(IncludeAttributeMethod<ASTNODE> spec) { + public <ASTNODE> DumpBuilder includeAttribute(IncludeAttributeMethod<ASTNODE> spec) { dumpAst.getBuildConfig().setIncludeAttributeMethod(spec); - if (!dumpAst.getBuildConfig().getGlobalPatternCollection().getAttributePattern().isEmpty()) { - System.err.println("Overriding previous filters for attributes"); - } - return thisWithResetBuilt(); - } - - /** - * Include attributes (as tokens) and their value if the attribute name matches at least on of the given regex strings. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param regex first pattern to match attribute name - * @param moreRegexes more patterns to match attribute names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder includeAttributes(String regex, String... moreRegexes) { - updateRegexes(() -> dumpAst.getBuildConfig().getGlobalPatternCollection().getAttributePattern(), - s -> dumpAst.getBuildConfig().getGlobalPatternCollection().setAttributePattern(s), - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Include attributes within a type (as tokens) and their value if the attribute name matches at least on of the given regex strings. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match attribute name - * @param moreRegexes more patterns to match attribute names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder includeAttributesFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateIncludePatternCollection(typeRegex); - updateRegexes(collection::getAttributePattern, - collection::setAttributePattern, - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Exclude attributes within a type (as tokens) and their value (again) if the attribute name matches at least on of the given regex strings. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match attribute name - * @param moreRegexes more patterns to match attribute names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder excludeAttributesFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateExcludePatternCollection(typeRegex); - updateRegexes(collection::getAttributePattern, - collection::setAttributePattern, - regex, moreRegexes); - return thisWithResetBuilt(); - } - - // --- Nonterminal-Attributes --- - - /** - * Includes nonterminal-attributes (as children) and their values if - * their attribute name matches at least on of the given regex strings. - * <br> - * <b>Note</b>: A leading "get" and a trailing "List" in the name will be removed prior to matching. - * Thus, it should not be contained in the regex either. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param regex first pattern to match attribute name - * @param moreRegexes more patterns to match attribute names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder includeNonterminalAttributes(String regex, String... moreRegexes) { - updateRegexes(() -> dumpAst.getBuildConfig().getGlobalPatternCollection().getNonterminalAttributePattern(), - s -> dumpAst.getBuildConfig().getGlobalPatternCollection().setNonterminalAttributePattern(s), - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Includes nonterminal-attributes (as children) and their values within a type if - * their attribute name matches at least on of the given regex strings. - * <br> - * <b>Note</b>: A leading "get" and a trailing "List" in the name will be removed prior to matching. - * Thus, it should not be contained in the regex either. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match attribute name - * @param moreRegexes more patterns to match attribute names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder includeNonterminalAttributesFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateIncludePatternCollection(typeRegex); - updateRegexes(collection::getNonterminalAttributePattern, - collection::setNonterminalAttributePattern, - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Excludes nonterminal-attributes (as children) and their values (again) within a type if - * their attribute name matches at least on of the given regex strings. - * <br> - * <b>Note</b>: A leading "get" and a trailing "List" in the name will be removed prior to matching. - * Thus, it should not be contained in the regex either. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match attribute name - * @param moreRegexes more patterns to match attribute names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder excludeNonterminalAttributesFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateExcludePatternCollection(typeRegex); - updateRegexes(collection::getNonterminalAttributePattern, - collection::setNonterminalAttributePattern, - regex, moreRegexes); return thisWithResetBuilt(); } // --- Relations --- - public <ASTNODE> DumpBuilder includeRelationsWhen(IncludeRelationMethod<ASTNODE> spec) { + public <ASTNODE> DumpBuilder includeRelation(IncludeRelationMethod<ASTNODE> spec) { dumpAst.getBuildConfig().setIncludeRelationMethod(spec); - if (!dumpAst.getBuildConfig().getGlobalPatternCollection().getRelationPattern().isEmpty()) { - System.err.println("Overriding previous filters for relations"); - } - return thisWithResetBuilt(); - } - - /** - * Exclude every relation whose role-name matches at least on of the given regex strings. - * This means two things: a) the relation to any potential target object(s) is never shown, and b) the target - * object(s) are not shown unless they are reachable by another relation or by containment. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param regex first pattern to match child name - * @param moreRegexes more patterns to match child names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder excludeRelations(String regex, String... moreRegexes) { - updateRegexes(() -> dumpAst.getBuildConfig().getGlobalPatternCollection().getRelationPattern(), - s -> dumpAst.getBuildConfig().getGlobalPatternCollection().setRelationPattern(s), - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Exclude every relation within a type whose role-name matches at least on of the given regex strings. - * This means two things: a) the relation to any potential target object(s) is never shown, and b) the target - * object(s) are not shown unless they are reachable by another relation or by containment. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match child name - * @param moreRegexes more patterns to match child names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder excludeRelationsFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateExcludePatternCollection(typeRegex); - updateRegexes(collection::getRelationPattern, - collection::setRelationPattern, - regex, moreRegexes); - return thisWithResetBuilt(); - } - - /** - * Include every relation (again) within a type whose role-name matches at least on of the given regex strings. - * This means two things: a) the relation to any potential target object(s) is never shown, and b) the target - * object(s) are not shown unless they are reachable by another relation or by containment. - * <p> - * See {@link DumpBuilder} for details on inclusion and exclusion precedence. - * - * @param typeRegex pattern to match a nonterminal name - * @param regex first pattern to match child name - * @param moreRegexes more patterns to match child names - * @return this - * @see java.util.regex.Pattern#compile(String) - */ - @Deprecated(since = "2.0.1") - public DumpBuilder includeRelationsFor(String typeRegex, String regex, String... moreRegexes) { - PatternCollection collection = findOrCreateIncludePatternCollection(typeRegex); - updateRegexes(collection::getRelationPattern, - collection::setRelationPattern, - regex, moreRegexes); return thisWithResetBuilt(); } @@ -653,6 +269,16 @@ public class DumpBuilder { } } + /** + * Return content as intermediate data structure used by the template engine. + * + * @return the intermediate data structure used by the template engine + * @throws TransformationException if {@link DumpAst#transform(TransformationTransferInformation, Object) transform} was not successful + */ + public String dumpAsYaml(boolean prependCreationComment) throws TransformationException { + return build().printYaml(prependCreationComment); + } + /** * Write out content as intermediate data structure used by the template engine. * @@ -668,6 +294,17 @@ public class DumpBuilder { } } + /** + * Write out content as PNG image generated by plantuml. + * + * @param os a stream to write to + * @throws IOException if an I/O error happened during writing in that stream + * @throws TransformationException if {@link DumpAst#transform(TransformationTransferInformation, Object) transform} was not successful + */ + public void dumpAsPNG(OutputStream os) throws TransformationException, IOException { + dumpAs(os, FileFormat.PNG); + } + /** * Write out content as PNG image generated by plantuml. * @@ -679,6 +316,17 @@ public class DumpBuilder { dumpAs(destination, FileFormat.PNG); } + /** + * Write out content as SVG image generated by plantuml. + * + * @param os a stream to write to + * @throws IOException if an I/O error happened during writing in that stream + * @throws TransformationException if {@link DumpAst#transform(TransformationTransferInformation, Object) transform} was not successful + */ + public void dumpAsSVG(OutputStream os) throws TransformationException, IOException { + dumpAs(os, FileFormat.SVG); + } + /** * Write out content as SVG image generated by plantuml. * @@ -690,6 +338,20 @@ public class DumpBuilder { dumpAs(destination, FileFormat.SVG); } + /** + * Write out content as PDF image generated by plantuml. + * + * <br> + * <b>Note:</b> This requires additional dependencies, see <a href="https://plantuml.com/pdf">https://plantuml.com/pdf</a> + * + * @param os a stream to write to + * @throws IOException if an I/O error happened during writing in that stream + * @throws TransformationException if {@link DumpAst#transform(TransformationTransferInformation, Object) transform} was not successful + */ + public void dumpAsPDF(OutputStream os) throws TransformationException, IOException { + dumpAs(os, FileFormat.PDF); + } + /** * Write out content as PDF generated by plantuml. * @@ -710,6 +372,12 @@ public class DumpBuilder { reader.outputImage(Files.newOutputStream(destination), new FileFormatOption(fileFormat)); } + private void dumpAs(OutputStream os, FileFormat fileFormat) throws IOException, TransformationException { + String content = build().toPlantUml(); + SourceStringReader reader = new SourceStringReader(content); + reader.outputImage(os, new FileFormatOption(fileFormat)); + } + // --- Helper methods --- protected DumpAst build() throws TransformationException { @@ -735,30 +403,6 @@ public class DumpBuilder { return dumpAst; } - private PatternCollection findOrCreateIncludePatternCollection(String typeRegex) { - PatternCollection result = dumpAst.getBuildConfig().findIncludePatternCollection(typeRegex); - if (result == null) { - TypePatternCollectionMapping mapping = new TypePatternCollectionMapping(); - mapping.setTypeRegex(typeRegex); - result = new PatternCollection(); - mapping.setPatternCollection(result); - dumpAst.getBuildConfig().addIncludeTypePattern(mapping); - } - return result; - } - - private PatternCollection findOrCreateExcludePatternCollection(String typeRegex) { - PatternCollection result = dumpAst.getBuildConfig().findExcludePatternCollection(typeRegex); - if (result == null) { - TypePatternCollectionMapping mapping = new TypePatternCollectionMapping(); - mapping.setTypeRegex(typeRegex); - result = new PatternCollection(); - mapping.setPatternCollection(result); - dumpAst.getBuildConfig().addExcludeTypePattern(mapping); - } - return result; - } - private void updateRegexes(Supplier<String> getter, Consumer<String> setter, String regex, String... moreRegexes) { if (getter.get().isEmpty()) { setter.accept(regex); diff --git a/dumpAst.prototyping/src/main/java/de/tudresden/inf/st/jastadd/featureTest/FeatureTestMain.java b/dumpAst.prototyping/src/main/java/de/tudresden/inf/st/jastadd/featureTest/FeatureTestMain.java index ea4c63182989f237fdc72a7c88b57f53b5048bc3..10e3f6afd2bd043499bd9788f4168cceb98803b7 100644 --- a/dumpAst.prototyping/src/main/java/de/tudresden/inf/st/jastadd/featureTest/FeatureTestMain.java +++ b/dumpAst.prototyping/src/main/java/de/tudresden/inf/st/jastadd/featureTest/FeatureTestMain.java @@ -47,7 +47,7 @@ public class FeatureTestMain { // .customPreamble("hide empty members") .enableDebug() .customPreamble("title My fancy title") - .includeChildWhen((parentNode, childNode, contextName) -> { + .includeChild((parentNode, childNode, contextName) -> { if (parentNode instanceof A && ((A) parentNode).getName().equals("A2")) { return false; } @@ -56,9 +56,9 @@ public class FeatureTestMain { } return !contextName.equals("MyC"); }) - .includeRelationsWhen((sourceNode, targetNode, roleName) -> + .includeRelation((sourceNode, targetNode, roleName) -> !(sourceNode instanceof B) || !((B) sourceNode).getName().equals("B6.1.1")) - .includeAttributeWhen((node, attributeName, isNTA, supplier) -> { + .includeAttribute((node, attributeName, isNTA, supplier) -> { switch (attributeName) { case "referenceAttr": case "collectBs": diff --git a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java index c3f6c1100a5f3af74ace6404af360aa3421c4005..3e49f20365ea41a83ec4a1cac5a544e26f8b7a5b 100644 --- a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java +++ b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java @@ -198,7 +198,8 @@ public class TestExcluded { c.setBiA1(a); })); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTokens(TOKEN_LABEL_UNWANTED)); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeToken((node, tokenName, value) -> + !tokenName.equals(TOKEN_LABEL_UNWANTED))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, C_NAME); DumpNode actualC = findByName(nodes, C_NAME); assertThat(valueTokens(actualC)).containsOnly( @@ -218,7 +219,8 @@ public class TestExcluded { c.setBiA1(a); })); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTokens(TOKEN_LABEL_UNWANTED, TOKEN_LABEL_RAW_REFERENCE)); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeToken((node, tokenName, value) -> + !tokenName.equals(TOKEN_LABEL_UNWANTED) && !tokenName.equals(TOKEN_LABEL_RAW_REFERENCE))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, C_NAME); DumpNode actualC = findByName(nodes, C_NAME); assertThat(valueTokens(actualC)).containsOnly( @@ -238,7 +240,8 @@ public class TestExcluded { c.setBiA1(a); })); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTokens("bi.*")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeToken((node, tokenName, value) -> + !tokenName.startsWith("bi"))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, C_NAME); DumpNode actualC = findByName(nodes, C_NAME); assertThat(valueTokens(actualC)).containsOnly( @@ -258,7 +261,8 @@ public class TestExcluded { c.setBiA1(a); })); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTokens("Bi.*")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeToken((node, tokenName, value) -> + !tokenName.startsWith("Bi"))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, C_NAME); DumpNode actualC = findByName(nodes, C_NAME); assertThat(valueTokens(actualC)).containsOnly( @@ -312,7 +316,8 @@ public class TestExcluded { }), null); root.getA().getB().setOneA(root.getA().getMyC().getA()); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeChildren("MyC")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeChild((parentNode, childNode, contextName) -> + !contextName.equals("MyC"))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder( ROOT_NAME, A_NAME, B_NAME, A2_Name, B2_NAME); DumpNode actualA = findByName(nodes, A_NAME); @@ -333,7 +338,8 @@ public class TestExcluded { public void testRelationsExclude() throws TransformationException { Root root = setupAllRelations(); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeRelations("BiC1")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeRelation((sourceNode, targetNode, roleName) -> + !roleName.equals("BiC1"))); // A assertThatMapOf(normalRelationChildren(findByName(nodes, A_NAME))).containsExactlyInAnyOrder( tuple("BiC2", C_NAME), tuple("BiC3", C_NAME)); @@ -352,7 +358,8 @@ public class TestExcluded { public void testRelationsExcludeRegex1() throws TransformationException { Root root = setupAllRelations(); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeRelations("Bi.*")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeRelation((sourceNode, targetNode, roleName) -> + !roleName.startsWith("Bi"))); // A assertThat(normalRelationChildren(findByName(nodes, A_NAME))).isEmpty(); // B @@ -369,7 +376,8 @@ public class TestExcluded { public void testRelationsExcludeRegex2() throws TransformationException { Root root = setupAllRelations(); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeRelations(".*A.*")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeRelation((sourceNode, targetNode, roleName) -> + !roleName.contains("A"))); // A assertThatMapOf(normalRelationChildren(findByName(nodes, A_NAME))).containsExactlyInAnyOrder( tuple("BiC1", C_NAME), tuple("BiC2", C_NAME), tuple("BiC3", C_NAME)); diff --git a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestIncluded.java b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestIncluded.java index 4d9d20e75ecb438ed0b21c04d898ec7384c6b0d4..e03718c7c9e3935507de7ca670b901e31db85a5c 100644 --- a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestIncluded.java +++ b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestIncluded.java @@ -26,7 +26,8 @@ public class TestIncluded { public void testValueAttributeIncluded() throws TransformationException { Root root = createRoot(null, null); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeAttributes("simpleAttr")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> + db.includeAttribute((node, attributeName, isNTA, value) -> !isNTA && attributeName.equals("simpleAttr"))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactly(ROOT_NAME); DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME); assertThat(valueTokens(actualRoot)).containsOnly(entry("Name", ROOT_NAME), entry("simpleAttr", 42)); @@ -36,7 +37,8 @@ public class TestIncluded { public void testReferenceListAttributeIncluded() throws TransformationException { Root root = createRoot(null, null, createB(B1_NAME), createB(B2_NAME), createB(B3_NAME)); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeAttributes("setOfBs")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> + db.includeAttribute((node, attributeName, isNTA, value) -> !isNTA && attributeName.equals("setOfBs"))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactly(ROOT_NAME, B1_NAME, B2_NAME, B3_NAME); DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME); @@ -58,7 +60,8 @@ public class TestIncluded { public void testReferenceAttributeIncluded() throws TransformationException { Root root = createRoot(createA(A_NAME), null); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeAttributes("referenceAttr")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> + db.includeAttribute((node, attributeName, isNTA, value) -> !isNTA && attributeName.equals("referenceAttr"))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactly(ROOT_NAME, A_NAME); DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME); assertThatMapOf(referenceTokens(actualRoot)).containsOnly(tuple("referenceAttr", A_NAME)); @@ -78,7 +81,8 @@ public class TestIncluded { public void testNormalNTAIncluded() throws TransformationException { Root root = createRoot(null, createC(C_NAME)); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeNonterminalAttributes("Calculated")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> + db.includeAttribute((node, attributeName, isNTA, value) -> isNTA && attributeName.equals("Calculated"))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactly(ROOT_NAME, C_NAME, "Calculated-" + C_NAME); DumpNode actualC = TestUtils.findByName(nodes, C_NAME); assertThatMapOf(normalChildren(actualC)).containsOnly(tuple("Calculated", "Calculated-" + C_NAME)); @@ -99,7 +103,8 @@ public class TestIncluded { public void testListNTAIncluded() throws TransformationException { Root root = createRoot(null, createC(C_NAME)); - List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.includeNonterminalAttributes("AlsoCalculated")); + List<DumpNode> nodes = TestUtils.dumpModel(root, db -> + db.includeAttribute((node, attributeName, isNTA, value) -> isNTA && attributeName.equals("AlsoCalculated"))); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactly(ROOT_NAME, C_NAME, "AlsoCalculated-" + C_NAME); DumpNode actualC = TestUtils.findByName(nodes, C_NAME); assertThatMapOf(listChildren(actualC), "AlsoCalculated").containsExactly("AlsoCalculated-" + C_NAME); diff --git a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java deleted file mode 100644 index 1e6759d147b88430fc5cd5ba7009d030fc63565e..0000000000000000000000000000000000000000 --- a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java +++ /dev/null @@ -1,222 +0,0 @@ -package de.tudresden.inf.st.jastadd.testDumper; - -import de.tudresden.inf.st.jastadd.dumpAst.ast.DumpNode; -import de.tudresden.inf.st.jastadd.dumpAst.ast.TransformationException; -import org.jastadd.testDumper.ast.A; -import org.jastadd.testDumper.ast.AbstractT; -import org.jastadd.testDumper.ast.TRoot; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; - -import java.util.List; -import java.util.function.Consumer; - -import static de.tudresden.inf.st.jastadd.testDumper.TestUtils.*; -import static org.assertj.core.api.Assertions.*; - -/** - * Testing type-level exclusions. - * <p> - * Refer to {@link de.tudresden.inf.st.jastadd.dumpAst.ast.DumpBuilder DumpBuilder} for levels of inclusion/exclusion. - * - * @author rschoene - Initial contribution - */ -public class TestTypeLevel3 { - - @Test - public void testTokenLevel2Excluded() throws TransformationException { - Consumer<AbstractT> setUnwanted = t -> t.setUnwanted(5); - TRoot root = createTRoot(createA(A_NAME), createT1(setUnwanted), createT2(setUnwanted), createT3(setUnwanted)); - Assertions.assertEquals(5, root.getT2().getUnwanted()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, dp -> dp.excludeTokens("Unwanted")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - for (String name : Tx_NAMES) { - DumpNode actualTx = TestUtils.findByName(nodes, name); - assertThat(valueTokens(actualTx)).containsOnly(entry("Name", name)); - } - } - - @Test - public void testTokenLevel3SomeIncluded() throws TransformationException { - Consumer<AbstractT> setUnwanted = t -> t.setUnwanted(5); - TRoot root = createTRoot(createA(A_NAME), createT1(setUnwanted), createT2(setUnwanted), createT3(setUnwanted)); - Assertions.assertEquals(5, root.getT2().getUnwanted()); - - List<DumpNode> nodesT2 = TestUtils.dumpModel(root, - dp -> dp.excludeTokens("Unwanted") - .includeTokensFor("T2", "Unwanted")); - assertThat(nodesT2).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - assertThat(valueTokens(TestUtils.findByName(nodesT2, T1_NAME))).containsOnly( - entry("Name", T1_NAME)); - assertThat(valueTokens(TestUtils.findByName(nodesT2, T2_NAME))).containsOnly( - entry("Name", T2_NAME), entry("Unwanted", 5)); - assertThat(valueTokens(TestUtils.findByName(nodesT2, T3_NAME))).containsOnly( - entry("Name", T3_NAME)); - - List<DumpNode> nodesT2T3 = TestUtils.dumpModel(root, - dp -> dp.excludeTokens("Unwanted") - .includeTokensFor("T2|T3", "Unwanted")); - assertThat(nodesT2T3).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T1_NAME))).containsOnly( - entry("Name", T1_NAME)); - assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T2_NAME))).containsOnly( - entry("Name", T2_NAME), entry("Unwanted", 5)); - assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T3_NAME))).containsOnly( - entry("Name", T3_NAME), entry("Unwanted", 5)); - } - - @Test - public void testNormalChildLevel2Excluded() throws TransformationException { - Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME)); - TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB)); - Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, dp -> dp.excludeChildren("B")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - for (String name : Tx_NAMES) { - DumpNode actualTx = TestUtils.findByName(nodes, name); - assertThat(normalChildren(actualTx)).isEmpty(); - } - } - - @Test - public void testNormalChildLevel3SomeIncluded() throws TransformationException { - Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME)); - TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB)); - Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, - dp -> dp.excludeChildren("B") - .includeChildrenFor("T2", "B")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T2_NAME + B_NAME); - assertThat(normalChildren(TestUtils.findByName(nodes, T1_NAME))).isEmpty(); - assertThatMapOf(normalChildren(TestUtils.findByName(nodes, T2_NAME))).containsOnly( - tuple("B", T2_NAME + B_NAME)); - assertThat(normalChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty(); - } - - @Test - public void testListChildLevel2Excluded() throws TransformationException { - Consumer<AbstractT> addBee = t -> t.addBee(createB(t.getName() + B_NAME)); - TRoot root = createTRoot(createA(A_NAME), createT1(addBee), createT2(addBee), createT3(addBee)); - Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getBee(0).getName()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, - dp -> dp.excludeChildren("Bee")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - for (String name : Tx_NAMES) { - assertEmpty(findByName(nodes, name).getDumpChildNode(0)); - } - } - - @Test - public void testListChildLevel3SomeIncluded() throws TransformationException { - Consumer<AbstractT> addBee = t -> t.addBee(createB(t.getName() + B_NAME)); - TRoot root = createTRoot(createA(A_NAME), createT1(addBee), createT2(addBee), createT3(addBee)); - Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getBee(0).getName()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, - dp -> dp.excludeChildren("Bee") - .includeChildrenFor("T2", "Bee")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T2_NAME + B_NAME); - assertEmpty(findByName(nodes, T1_NAME).getDumpChildNode(0)); - assertThatMapOf(listChildren(TestUtils.findByName(nodes, T2_NAME)), "Bee").containsOnly( - T2_NAME + B_NAME); - assertEmpty(TestUtils.findByName(nodes, T3_NAME).getDumpChildNode(0)); - } - - @Test - public void testRelationLevel2Excluded() throws TransformationException { - final A a = createA(A_NAME); - Consumer<AbstractT> setOneA = t -> t.setOneA(a); - TRoot root = createTRoot(a, createT1(setOneA), createT2(setOneA), createT3(setOneA)); - Assertions.assertEquals(a, root.getT2().getOneA()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, dp -> dp.excludeRelations("OneA")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - for (String name : Tx_NAMES) { - DumpNode actualTx = TestUtils.findByName(nodes, name); - assertThat(normalRelationChildren(actualTx)).isEmpty(); - } - } - - @Test - public void testRelationLevel3SomeIncluded() throws TransformationException { - final A a = createA(A_NAME); - Consumer<AbstractT> setOneA = t -> t.setOneA(a); - TRoot root = createTRoot(a, createT1(setOneA), createT2(setOneA), createT3(setOneA)); - Assertions.assertEquals(a, root.getT2().getOneA()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, - dp -> dp.excludeRelations("OneA") - .includeRelationsFor("T2", "OneA")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - assertThat(normalRelationChildren(TestUtils.findByName(nodes, T1_NAME))).isEmpty(); - assertThatMapOf(normalRelationChildren(TestUtils.findByName(nodes, T2_NAME))).containsOnly( - tuple("OneA", A_NAME)); - assertThat(normalRelationChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty(); - } - - @Test - public void testAttributeLevel2Included() throws TransformationException { - TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.includeAttributes("simpleAttr")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - for (String name : Tx_NAMES) { - DumpNode actualTx = findByName(nodes, name); - assertThat(valueTokens(actualTx)).containsOnly( - entry("Name", name), - entry(TOKEN_LABEL_UNWANTED, 0), - entry("simpleAttr", 43)); - } - } - - @Test - public void testAttributeLevel3SomeExcluded() throws TransformationException { - TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.includeAttributes("simpleAttr") - .excludeAttributesFor("T2", "simpleAttr")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - assertThat(valueTokens(findByName(nodes, T1_NAME))).containsOnly( - entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 0), entry("simpleAttr", 43)); - assertThat(valueTokens(findByName(nodes, T2_NAME))).containsOnly( - entry("Name", T2_NAME), entry(TOKEN_LABEL_UNWANTED, 0)); - assertThat(valueTokens(findByName(nodes, T3_NAME))).containsOnly( - entry("Name", T3_NAME), entry(TOKEN_LABEL_UNWANTED, 0), entry("simpleAttr", 43)); - } - - @Test - public void testNTALevel2Included() throws TransformationException { - TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.includeNonterminalAttributes("Calculated")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, "Calculated-" + T1_NAME, "Calculated-" + T2_NAME, "Calculated-" + T3_NAME); - for (String name : Tx_NAMES) { - assertThatMapOf(normalChildren(findByName(nodes, name))).containsOnly( - tuple("Calculated", "Calculated-" + name)); - } - } - - @Test - public void testNTALevel3SomeExcluded() throws TransformationException { - TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.includeNonterminalAttributes("Calculated") - .excludeNonterminalAttributesFor("T2", "Calculated")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, "Calculated-" + T1_NAME, "Calculated-" + T3_NAME); - assertThatMapOf(normalChildren(findByName(nodes, T1_NAME))).containsOnly( - tuple("Calculated", "Calculated-" + T1_NAME)); - assertThat(normalChildren(findByName(nodes, T2_NAME))).isEmpty(); - assertThatMapOf(normalChildren(findByName(nodes, T3_NAME))).containsOnly( - tuple("Calculated", "Calculated-" + T3_NAME)); - } - -} diff --git a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java deleted file mode 100644 index 78f4bc9ccb466f07210a54aecafaf8a80d5eac94..0000000000000000000000000000000000000000 --- a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java +++ /dev/null @@ -1,245 +0,0 @@ -package de.tudresden.inf.st.jastadd.testDumper; - -import de.tudresden.inf.st.jastadd.dumpAst.ast.DumpNode; -import de.tudresden.inf.st.jastadd.dumpAst.ast.TransformationException; -import org.jastadd.testDumper.ast.A; -import org.jastadd.testDumper.ast.AbstractT; -import org.jastadd.testDumper.ast.TRoot; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; - -import java.util.List; -import java.util.function.Consumer; - -import static de.tudresden.inf.st.jastadd.testDumper.TestUtils.*; -import static org.assertj.core.api.Assertions.*; - -/** - * Testing type-level inclusions. - * <p> - * Refer to {@link de.tudresden.inf.st.jastadd.dumpAst.ast.DumpBuilder DumpBuilder} for levels of inclusion/exclusion. - * - * @author rschoene - Initial contribution - */ -public class TestTypeLevel4 { - - @Test - public void testTokenLevel3Included() throws TransformationException { - Consumer<AbstractT> setUnwanted = t -> t.setUnwanted(5); - TRoot root = createTRoot(createA(A_NAME, createC(C_NAME, c -> c.setUnwanted(6))), - createT1(setUnwanted), createT2(setUnwanted), createT3(setUnwanted)); - Assertions.assertEquals(5, root.getT2().getUnwanted()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.excludeTokens(TOKEN_LABEL_UNWANTED) - .includeTokensFor("T.", TOKEN_LABEL_UNWANTED)); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder( - ROOT_NAME, A_NAME, C_NAME, T1_NAME, T2_NAME, T3_NAME); - for (String name : Tx_NAMES) { - DumpNode actualTx = findByName(nodes, name); - assertThat(valueTokens(actualTx)).containsOnly(entry("Name", name), entry(TOKEN_LABEL_UNWANTED, 5)); - } - assertThat(valueTokens(findByName(nodes, C_NAME))).containsOnly( - entry("Name", C_NAME)); - } - - @Test - public void testTokenLevel4SomeExcluded() throws TransformationException { - Consumer<AbstractT> setUnwanted = t -> t.setUnwanted(5); - TRoot root = createTRoot(createA(A_NAME, createC(C_NAME, c -> c.setUnwanted(6))), - createT1(setUnwanted), createT2(setUnwanted), createT3(setUnwanted)); - Assertions.assertEquals(5, root.getT2().getUnwanted()); - - List<DumpNode> nodesT2 = dumpModel(root, - dp -> dp.excludeTokens(TOKEN_LABEL_UNWANTED) - .includeTokensFor("T.", TOKEN_LABEL_UNWANTED) - .excludeTokensFor("T3", TOKEN_LABEL_UNWANTED)); - assertThat(nodesT2).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder( - ROOT_NAME, A_NAME, C_NAME, T1_NAME, T2_NAME, T3_NAME); - assertThat(valueTokens(findByName(nodesT2, T1_NAME))).containsOnly( - entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 5)); - assertThat(valueTokens(findByName(nodesT2, T2_NAME))).containsOnly( - entry("Name", T2_NAME), entry(TOKEN_LABEL_UNWANTED, 5)); - assertThat(valueTokens(findByName(nodesT2, T3_NAME))).containsOnly( - entry("Name", T3_NAME)); - assertThat(valueTokens(findByName(nodesT2, C_NAME))).containsOnly( - entry("Name", C_NAME)); - - List<DumpNode> nodesT2T3 = dumpModel(root, - dp -> dp.excludeTokens(TOKEN_LABEL_UNWANTED) - .includeTokensFor("T.", TOKEN_LABEL_UNWANTED) - .excludeTokensFor("T2|T3", TOKEN_LABEL_UNWANTED)); - assertThat(nodesT2T3).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder( - ROOT_NAME, A_NAME, C_NAME, T1_NAME, T2_NAME, T3_NAME); - assertThat(valueTokens(findByName(nodesT2T3, T1_NAME))).containsOnly( - entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 5)); - assertThat(valueTokens(findByName(nodesT2T3, T2_NAME))).containsOnly( - entry("Name", T2_NAME)); - assertThat(valueTokens(findByName(nodesT2T3, T3_NAME))).containsOnly( - entry("Name", T3_NAME)); - assertThat(valueTokens(findByName(nodesT2T3, C_NAME))).containsOnly( - entry("Name", C_NAME)); - } - - @Test - public void testNormalChildLevel3Included() throws TransformationException { - Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME)); - TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB)); - Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.excludeChildren("B") - .includeChildrenFor("T.", "B")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T1_NAME + B_NAME, T2_NAME + B_NAME, T3_NAME + B_NAME); - for (String name : Tx_NAMES) { - assertThatMapOf(normalChildren(findByName(nodes, name))).containsOnly( - tuple("B", name + B_NAME)); - } - } - - @Test - public void testNormalChildLevel4SomeExcluded() throws TransformationException { - Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME)); - TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB)); - Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.excludeChildren("B") - .includeChildrenFor("T.", "B") - .excludeChildrenFor("T3", "B")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T1_NAME + B_NAME, T2_NAME + B_NAME); - assertThatMapOf(normalChildren(findByName(nodes, T1_NAME))).containsOnly( - tuple("B", T1_NAME + B_NAME)); - assertThatMapOf(normalChildren(findByName(nodes, T2_NAME))).containsOnly( - tuple("B", T2_NAME + B_NAME)); - assertThat(normalChildren(findByName(nodes, T3_NAME))).isEmpty(); - } - - @Test - public void testListChildLevel3Included() throws TransformationException { - Consumer<AbstractT> addBee = t -> t.addBee(createB(t.getName() + B_NAME)); - TRoot root = createTRoot(createA(A_NAME), createT1(addBee), createT2(addBee), createT3(addBee)); - Assertions.assertEquals(T3_NAME + B_NAME, root.getT3().getBee(0).getName()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.excludeChildren("Bee") - .includeChildrenFor("T.", "Bee")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T1_NAME + B_NAME, T2_NAME + B_NAME, T3_NAME + B_NAME); - for (String name : Tx_NAMES) { - assertThatMapOf(listChildren(findByName(nodes, name)), "Bee").containsOnly( - name + B_NAME); - } - } - - @Test - public void testListChildLevel4SomeExcluded() throws TransformationException { - Consumer<AbstractT> addBee = t -> t.addBee(createB(t.getName() + B_NAME)); - TRoot root = createTRoot(createA(A_NAME), createT1(addBee), createT2(addBee), createT3(addBee)); - Assertions.assertEquals(T3_NAME + B_NAME, root.getT3().getBee(0).getName()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.excludeChildren("Bee") - .includeChildrenFor("T.", "Bee") - .excludeChildrenFor("T3", "Bee")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T1_NAME + B_NAME, T2_NAME + B_NAME); - assertThatMapOf(listChildren(findByName(nodes, T1_NAME)), "Bee").containsOnly( - T1_NAME + B_NAME); - assertThatMapOf(listChildren(findByName(nodes, T2_NAME)), "Bee").containsOnly( - T2_NAME + B_NAME); - assertEmpty(findByName(nodes, T3_NAME).getDumpChildNode(0)); - } - - @Test - public void testRelationLevel3Included() throws TransformationException { - final A a = createA(A_NAME); - Consumer<AbstractT> setOneA = t -> t.setOneA(a); - TRoot root = createTRoot(a, createT1(setOneA), createT2(setOneA), createT3(setOneA)); - Assertions.assertEquals(a, root.getT2().getOneA()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.excludeRelations("OneA") - .includeRelationsFor("T2", "OneA")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - assertThat(normalRelationChildren(findByName(nodes, T1_NAME))).isEmpty(); - assertThatMapOf(normalRelationChildren(findByName(nodes, T2_NAME))).containsOnly( - tuple("OneA", A_NAME)); - assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty(); - } - - @Test - public void testRelationLevel4SomeExcluded() throws TransformationException { - final A a = createA(A_NAME); - Consumer<AbstractT> setOneA = t -> t.setOneA(a); - TRoot root = createTRoot(a, createT1(setOneA), createT2(setOneA), createT3(setOneA)); - Assertions.assertEquals(a, root.getT2().getOneA()); - - List<DumpNode> nodes = dumpModel(root, - dp -> dp.excludeRelations("OneA") - .includeRelationsFor("T.", "OneA") - .excludeRelationsFor("T3", "OneA")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - assertThatMapOf(normalRelationChildren(findByName(nodes, T1_NAME))).containsOnly( - tuple("OneA", A_NAME)); - assertThatMapOf(normalRelationChildren(findByName(nodes, T2_NAME))).containsOnly( - tuple("OneA", A_NAME)); - assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty(); - } - - @Test - public void testAttributeLevel3Excluded() throws TransformationException { - TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, - dp -> dp.includeAttributes("simpleAttr") - .excludeAttributesFor("T.", "simpleAttr")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - for (String name : Tx_NAMES) { - DumpNode actualTx = TestUtils.findByName(nodes, name); - assertThat(valueTokens(actualTx)).containsOnly( - entry("Name", name), entry(TOKEN_LABEL_UNWANTED, 0)); - } - } - - @Test - public void testAttributeLevel4SomeIncluded() throws TransformationException { - TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, - dp -> dp.includeAttributes("simpleAttr") - .excludeAttributesFor("T.", "simpleAttr") - .includeAttributesFor("T3", "simpleAttr")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - assertThat(valueTokens(TestUtils.findByName(nodes, T1_NAME))).containsOnly( - entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 0)); - assertThat(valueTokens(TestUtils.findByName(nodes, T2_NAME))).containsOnly( - entry("Name", T2_NAME), entry(TOKEN_LABEL_UNWANTED, 0)); - assertThat(valueTokens(TestUtils.findByName(nodes, T3_NAME))).containsOnly( - entry("Name", T3_NAME), entry(TOKEN_LABEL_UNWANTED, 0), entry("simpleAttr", 43)); - } - - @Test - public void testNTALevel3Excluded() throws TransformationException { - TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, - dp -> dp.includeNonterminalAttributes("Calculated") - .excludeNonterminalAttributesFor("T.", "Calculated")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); - DumpNode actualT3 = TestUtils.findByName(nodes, T3_NAME); - assertThat(normalChildren(actualT3)).isEmpty(); - } - - @Test - public void testNTALevel4SomeIncluded() throws TransformationException { - TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3()); - - List<DumpNode> nodes = TestUtils.dumpModel(root, - dp -> dp.includeNonterminalAttributes("Calculated") - .excludeNonterminalAttributesFor("T.", "Calculated") - .includeNonterminalAttributesFor("T3", "Calculated")); - assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, "Calculated-" + T3_NAME); - DumpNode actualT3 = TestUtils.findByName(nodes, T3_NAME); - assertThatMapOf(normalChildren(actualT3)).containsOnly(tuple("Calculated", "Calculated-" + T3_NAME)); - } - -}