#4478

monticore-runtime/src/main/java/de/monticore/generating/templateengine/GlobalExtensionManagement.java

@@ -2,7 +2,6 @@
 
 package de.monticore.generating.templateengine;
 
-import com.google.common.base.Strings;
 import com.google.common.collect.*;
 import de.monticore.ast.ASTNode;
 import de.monticore.generating.templateengine.freemarker.SimpleHashFactory;
@@ -18,6 +17,12 @@
 /**
  * Class for managing hook points, features and (global) variables in templates.
  *
+ * Order of template replacement:
+ *   - specific before hook points
+ *   - general before hook points
+ *   - specific replacement or general replacement
+ *   - specific after hook points
+ *   - general after hook points
  */
 public class GlobalExtensionManagement {
 
@@ -463,16 +468,17 @@ protected List<HookPoint> getTemplateForwardings(String templateName, ASTNode as
     List<HookPoint> replacements = Lists.newArrayList();
 
     // Before replacement
-    List<HookPoint> beforeHooks;
+    List<HookPoint> beforeHooks = Lists.newArrayList();
     if (this.specificBefore.contains(templateName, ast)) {
-      beforeHooks = this.specificBefore.get(templateName, ast);
+      beforeHooks.addAll(this.specificBefore.get(templateName, ast));
       Reporting.reportAddBeforeTemplate(templateName, Optional.of(ast), beforeHooks);
-    } else {
-      beforeHooks = Lists.newArrayList(this.before.get(templateName));
-      if (!beforeHooks.isEmpty()) {
-        Reporting.reportCallBeforeHookPoint(templateName, beforeHooks, ast);
-      }
     }
+    List<HookPoint> hooks = Lists.newArrayList(this.before.get(templateName));
+    if (!hooks.isEmpty()) {
+      beforeHooks.addAll(hooks);
+      Reporting.reportCallBeforeHookPoint(templateName, hooks, ast);
+    }
+
     replacements.addAll(beforeHooks);
 
     // "normal" replacement
@@ -485,15 +491,16 @@ protected List<HookPoint> getTemplateForwardings(String templateName, ASTNode as
     replacements.addAll(hps);
 
     // After replacement
-    List<HookPoint> afterHooks;
+    List<HookPoint> afterHooks = Lists.newArrayList();
     if (this.specificAfter.contains(templateName, ast)) {
       afterHooks = this.specificAfter.get(templateName, ast);
       Reporting.reportAddAfterTemplate(templateName, Optional.of(ast), afterHooks);
-    } else {
-      afterHooks = Lists.newArrayList(this.after.get(templateName));
-      if (!afterHooks.isEmpty()) {
-        Reporting.reportCallAfterHookPoint(templateName, afterHooks, ast);
-      }
+    }
+    hooks = Lists.newArrayList(this.after.get(templateName));
+    if (!hooks.isEmpty()) {
+      afterHooks.addAll(hooks);
+      Reporting.reportCallAfterHookPoint(templateName, hooks, ast);
+
     }
     replacements.addAll(afterHooks);
 

monticore-runtime/src/test/java/de/monticore/generating/templateengine/TemplateControllerHookPointsTest.java

@@ -8,6 +8,7 @@
 import java.io.IOException;
 import java.util.Arrays;
 
+import com.google.common.collect.Lists;
 import de.monticore.ast.ASTNode;
 import de.monticore.ast.ASTNodeMock;
 import de.monticore.io.FileReaderWriter;
@@ -228,6 +229,208 @@ public void testSpecificBeforeTemplates() {
 
   }
 
+  @Test
+  public void testOrderOfBeforeTemplates() {
+    ASTNode ast1 = new ASTNodeMock();
+
+    // Add specific template
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("BCA", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // set specific template
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("CA", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add general template
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A",  new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A",  new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("BCA", tc.include(TEMPLATE_PACKAGE + "A").toString());
+
+    // Reset
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // set general template
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("CA", tc.include(TEMPLATE_PACKAGE + "A").toString());
+
+    // Reset
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add and set specific template
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("CA", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Set and add  specific template
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("BCA", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add and set general template
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("CA", tc.include(TEMPLATE_PACKAGE + "A").toString());
+
+    // Reset
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Set and add general template
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("BCA", tc.include(TEMPLATE_PACKAGE + "A").toString());
+
+    // Reset
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add specific and general template
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("BCA", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add general and specific template
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("CBA", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Set specific and general template
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("BCA", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Set general and specific template
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setBeforeTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("CBA", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+  }
+
+  @Test
+  public void testOrderOfAfterTemplates() {
+    ASTNode ast1 = new ASTNodeMock();
+
+    // Add specific template
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("ABC", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // set specific template
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("AC", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add general template
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A",  new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A",  new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("ABC", tc.include(TEMPLATE_PACKAGE + "A").toString());
+
+    // Reset
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // set general template
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("AC", tc.include(TEMPLATE_PACKAGE + "A").toString());
+
+    // Reset
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add and set specific template
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("AC", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Set and add  specific template
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("ABC", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add and set general template
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("AC", tc.include(TEMPLATE_PACKAGE + "A").toString());
+
+    // Reset
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Set and add general template
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("ABC", tc.include(TEMPLATE_PACKAGE + "A").toString());
+
+    // Reset
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add specific and general template
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("ABC", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Reset
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, Lists.newArrayList());
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", Lists.newArrayList());
+
+    // Add general and specific template
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.addAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("ACB", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Set specific and general template
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("ABC", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+
+    // Set general and specific template
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", new TemplateHookPoint(TEMPLATE_PACKAGE + "B"));
+    glex.setAfterTemplate(TEMPLATE_PACKAGE + "A", ast1, new TemplateHookPoint(TEMPLATE_PACKAGE + "C"));
+    Assertions.assertEquals("ACB", tc.include(TEMPLATE_PACKAGE + "A", ast1).toString());
+  }
+
   @Test
   public void testAfterTemplates() {
     Assertions.assertEquals("A", tc.include(TEMPLATE_PACKAGE + "A").toString());