Add blacklisting and TeammatesRules

Author: FloBoJa

bundles/org.palladiosimulator.retriever.extraction.rules/plugin.xml

@@ -81,5 +81,13 @@
           class="org.palladiosimulator.retriever.extraction.rules.JaxRSDeploymentRules">
     </rule>
  </extension>
+ <extension
+       id="org.palladiosimulator.retriever.extraction.rules.teammates"
+       name="Teammates Rules"
+       point="org.palladiosimulator.retriever.services.rule">
+    <rule
+          class="org.palladiosimulator.retriever.extraction.rules.TeammatesRules">
+    </rule>
+ </extension>
 
 </plugin>

bundles/org.palladiosimulator.retriever.extraction.rules/src/org/palladiosimulator/retriever/extraction/rules/TeammatesRules.xtend

@@ -0,0 +1,43 @@
+package org.palladiosimulator.retriever.extraction.rules
+
+import java.nio.file.Path;
+import java.util.Set
+import org.palladiosimulator.retriever.services.blackboard.RetrieverBlackboard
+import org.palladiosimulator.retriever.services.Rule
+import org.palladiosimulator.retriever.extraction.engine.PCMDetector
+
+class TeammatesRules implements Rule {
+
+	static final String RULE_ID = "org.palladiosimulator.retriever.extraction.rules.teammates"
+	static final String JAVA_DISCOVERER_ID = "org.palladiosimulator.retriever.extraction.discoverers.java"
+	static final String JAX_RS_RULES_ID = "org.palladiosimulator.retriever.extraction.rules.jax_rs"
+
+	override processRules(RetrieverBlackboard blackboard, Path path) {
+		val pcmDetector = blackboard.PCMDetector as PCMDetector;
+		pcmDetector.addToBlacklist("teammates.common.util.Logger");
+	}
+
+	override isBuildRule() {
+		true
+	}
+
+	override getConfigurationKeys() {
+		return Set.of
+	}
+
+	override getID() {
+		RULE_ID
+	}
+
+	override getName() {
+		"Teammates Rules"
+	}
+
+	override getRequiredServices() {
+		return Set.of(JAVA_DISCOVERER_ID)
+	}
+
+	override getDependentServices() {
+		Set.of(JAX_RS_RULES_ID)
+	}
+}

bundles/org.palladiosimulator.retriever.extraction/src/org/palladiosimulator/retriever/extraction/engine/PCMDetector.java

@@ -2,6 +2,8 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -47,6 +49,7 @@ public class PCMDetector {
     private final RequirementsBuilder compositeRequirements = new RequirementsBuilder();
     private final Map<CompUnitOrName, List<String>> weakComponents = new ConcurrentHashMap<>();
     private final Map<CompUnitOrName, String> separatingIdentifiers = new ConcurrentHashMap<>();
+    private final Set<String> blacklist = new HashSet<>();
 
     private static String getFullUnitName(final CompUnitOrName unit) {
         // TODO this is potentially problematic, maybe restructure
@@ -76,18 +79,13 @@ private static String getFullUnitName(final CompUnitOrName unit) {
 
     public void detectComponent(final CompUnitOrName unit) {
         if (!unit.isUnit()) {
-            if (this.components.get(unit) == null) {
-                this.components.put(unit, new ComponentBuilder(unit));
-            }
+            tryAddComponent(unit);
             return;
         }
         for (final Object type : unit.compilationUnit()
             .get()
             .types()) {
-            if (type instanceof TypeDeclaration) {
-                if (this.components.get(unit) == null) {
-                    this.components.put(unit, new ComponentBuilder(unit));
-                }
+            if (type instanceof TypeDeclaration && tryAddComponent(unit)) {
                 final ITypeBinding binding = ((TypeDeclaration) type).resolveBinding();
                 this.detectProvidedInterfaceWeakly(unit, binding);
             }
@@ -100,8 +98,8 @@ public void detectRequiredInterface(final CompUnitOrName unit, final InterfaceNa
 
     private void detectRequiredInterface(final CompUnitOrName unit, final InterfaceName interfaceName,
             final boolean compositeRequired) {
-        if (this.components.get(unit) == null) {
-            this.components.put(unit, new ComponentBuilder(unit));
+        if (!tryAddComponent(unit)) {
+            return;
         }
         final EntireInterface iface = new EntireInterface(interfaceName);
         this.detectRequiredInterface(unit, compositeRequired, false, iface);
@@ -117,8 +115,8 @@ public void detectRequiredInterfaceWeakly(final CompUnitOrName unit, final Field
 
     private void detectRequiredInterface(final CompUnitOrName unit, final FieldDeclaration field,
             final boolean compositeRequired, final boolean detectWeakly) {
-        if (this.components.get(unit) == null) {
-            this.components.put(unit, new ComponentBuilder(unit));
+        if (!tryAddComponent(unit)) {
+            return;
         }
         @SuppressWarnings("unchecked")
         final List<OperationInterface> ifaces = ((List<VariableDeclaration>) field.fragments()).stream()
@@ -136,17 +134,17 @@ public void detectCompositeRequiredInterfaceWeakly(final CompUnitOrName unit, fi
             return;
         }
         final ITypeBinding type = method.getDeclaringClass();
-        if (this.components.get(unit) == null) {
-            this.components.put(unit, new ComponentBuilder(unit));
+        if (!tryAddComponent(unit)) {
+            return;
         }
         final EntireInterface iface = new EntireInterface(type,
                 new JavaInterfaceName(NameConverter.toPCMIdentifier(type)));
         this.detectRequiredInterface(unit, true, true, iface);
     }
 
     public void detectRequiredInterface(final CompUnitOrName unit, final SingleVariableDeclaration parameter) {
-        if (this.components.get(unit) == null) {
-            this.components.put(unit, new ComponentBuilder(unit));
+        if (!tryAddComponent(unit)) {
+            return;
         }
         final IVariableBinding parameterBinding = parameter.resolveBinding();
         if (parameterBinding == null) {
@@ -245,8 +243,8 @@ public void detectProvidedOperation(final CompUnitOrName unit, final IMethodBind
 
     private void detectProvidedOperation(final CompUnitOrName unit, final IMethodBinding method,
             final OperationName name, final boolean compositeProvided, final boolean detectWeakly) {
-        if (this.components.get(unit) == null) {
-            this.components.put(unit, new ComponentBuilder(unit));
+        if (!tryAddComponent(unit)) {
+            return;
         }
         final OperationInterface provision = new Operation(method, name);
         this.detectProvidedInterface(unit, provision, compositeProvided, detectWeakly);
@@ -290,8 +288,8 @@ public void detectSeparatingIdentifier(final CompUnitOrName unit, final String s
     }
 
     public void detectPartOfComposite(final CompUnitOrName unit, final String compositeName) {
-        if (this.components.get(unit) == null) {
-            this.components.put(unit, new ComponentBuilder(unit));
+        if (!tryAddComponent(unit)) {
+            return;
         }
         if (!this.composites.containsKey(compositeName)) {
             this.composites.put(compositeName, new CompositeBuilder(compositeName));
@@ -380,4 +378,31 @@ public boolean isPartOfComposite(CompUnitOrName name) {
         }
         return false;
     }
+
+    public void addToBlacklist(String string) {
+        this.blacklist.add(string);
+
+        // Clean up already added but now blacklisted components
+        List<CompUnitOrName> toDelete = new LinkedList<>();
+        for (CompUnitOrName unit : this.components.keySet()) {
+            if (unit.name()
+                .equals(string)) {
+                toDelete.add(unit);
+            }
+        }
+        for (CompUnitOrName unit : toDelete) {
+            this.components.remove(unit);
+        }
+    }
+
+    private boolean tryAddComponent(CompUnitOrName unit) {
+        if (this.components.get(unit) != null) {
+            return true;
+        }
+        if (this.blacklist.contains(unit.name())) {
+            return false;
+        }
+        this.components.put(unit, new ComponentBuilder(unit));
+        return true;
+    }
 }