Refactor source file loader

Author: oshando

swan-pipeline/src/main/java/de/fraunhofer/iem/swan/SwanPipeline.java

@@ -135,7 +135,10 @@ public void run() throws IOException, InterruptedException {
         for (int x = 0; x < 10; x++)
             predictions.put(Integer.toString(x), new HashSet<>());
 
-        runClassEvaluation(options.getSrmClasses(), feature, learnerMode );
+        //Load methods from the test set
+        logger.info("Loading test JARs in {}", options.getTestDataDir());
+        SourceFileLoader testDataset = new SourceFileLoader(options.getTestDataDir());
+        testDataset.load(dataset.getMethods());
 
         // Save data from last classification.
         loader.resetMethods();

swan-pipeline/src/main/java/de/fraunhofer/iem/swan/features/code/soot/Loader.java

@@ -0,0 +1,70 @@
+package de.fraunhofer.iem.swan.features.code.soot;
+
+import de.fraunhofer.iem.swan.data.Method;
+import de.fraunhofer.iem.swan.features.code.type.AbstractSootFeature;
+import de.fraunhofer.iem.swan.util.SootUtils;
+import de.fraunhofer.iem.swan.util.Util;
+import soot.Scene;
+import soot.SootClass;
+import soot.SootMethod;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Set;
+
+public class SourceFileLoader {
+
+    private final String classpath;
+    private Set<Method> methods = new HashSet<>();
+    Set<String> testClasses;
+
+    public SourceFileLoader(String sourceFileDir) throws IOException {
+
+        testClasses = Util.getAllClassesFromDirectory(sourceFileDir);
+        this.classpath = Util.buildCP(sourceFileDir);
+    }
+
+    public void load(final Set<Method> trainingSet) {
+        loadMethodsFromTestLib();
+        Util.createSubclassAnnotations(methods, classpath);
+        methods = Util.sanityCheck(methods, trainingSet);
+    }
+
+    public void loadMethodsFromTestLib() {
+
+        new AbstractSootFeature(classpath) {
+
+            @Override
+            public Type appliesInternal(Method method) {
+
+                for (String className : testClasses) {
+                    SootClass sc = Scene.v().forceResolve(className, SootClass.HIERARCHY);
+
+                    if (sc == null || !testClasses.contains(sc.getName()))
+                        continue;
+
+                    if (!sc.isInterface() && !sc.isPrivate())
+                        for (SootMethod sm : sc.getMethods()) {
+                            if (sm.isConcrete()) {
+                                // This is done by hand here because of the cases where the
+                                // character ' is in the signature. This is not supported by the
+                                // current Soot.
+                                // TODO: Get Soot to support the character '
+                                methods.add(SootUtils.convertSootSignature(sm.getSignature()));
+                            }
+                        }
+                }
+                return Type.NOT_SUPPORTED;
+            }
+
+        }.applies(new Method("a", "void", "x.y"));
+    }
+
+    public Set<Method> getMethods() {
+        return methods;
+    }
+
+    public String getClasspath() {
+        return classpath;
+    }
+}

swan-pipeline/src/main/java/de/fraunhofer/iem/swan/features/code/soot/SourceFileLoader.java

@@ -133,15 +133,15 @@ public static Set<Method> extractMethodData(HashSet<String> classes, HashSet<Str
             methodSet.put(t.substring(0, t.indexOf("|")), t.substring(t.indexOf("|") + 1));
         }
 
-        Loader loader = new Loader(classpath);
-        loader.loadMethodsFromTestLib(testClasses);
+        SourceFileLoader sourceFileLoader = new SourceFileLoader(classpath);
+        sourceFileLoader.loadMethodsFromTestLib();
 
-        Util.createSubclassAnnotations(loader.methods(), classpath);
+        Util.createSubclassAnnotations(sourceFileLoader.getMethods(), classpath);
 
         HashSet<Method> trainingMethods = new HashSet<>();
 
 
-        for (Method m : loader.methods()) {
+        for (Method m : sourceFileLoader.getMethods()) {
 
             String sig = m.getClassName() + "." + m.getMethodName();
 

swan-pipeline/src/main/java/de/fraunhofer/iem/swan/training/TrainingSetUpdater.java

@@ -0,0 +1,39 @@
+package de.fraunhofer.iem.swan.util;
+
+import de.fraunhofer.iem.swan.data.Method;
+import java.util.Arrays;
+
+public class SootUtils {
+
+    public static Method convertSootSignature(String sootSignature){
+
+        //Ignore < and > at the beginning and end of the signature
+        String[] parts = sootSignature.substring(1, sootSignature.length()-1).split(":");
+
+        String className = parts[0];
+        String[] method = parts[1].trim().split(" ");
+        String returnType = method[0];
+        String methodName = method[1].substring(0, method[1].indexOf("("));
+        String[] paramList = method[1].substring(method[1].indexOf("(") + 1, method[1].indexOf(")")).split(",");
+
+        //TODO correctly handle <init> and <clinit>
+        if (methodName.contains("<init>"))
+            methodName = getSimpleName(className);
+
+        return new Method(methodName, Arrays.asList(paramList), returnType, className);
+    }
+
+    /**
+     * Returns last part of a fully qualified name string.
+     *
+     * @param value Namespace of object
+     * @return returns simple name
+     */
+    public static String getSimpleName(String value) {
+
+        if (!value.contains("."))
+            return value;
+        else
+            return value.substring(value.lastIndexOf(".") + 1);
+    }
+}