Merge pull request #125 from ml-in-programming/smartPsiElementPointer_integration

 Migration to SmartPsiElementPointer and erasing name-based search and identification.

Author: ujohnny

MetricsReloaded/src/test/java/com/sixrr/metrics/ui/SearchUtilTest.java

@@ -20,10 +20,9 @@
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Set;
 
-import static org.junit.Assert.*;
-import static com.sixrr.metrics.ui.SearchUtil.*;
+import static com.sixrr.metrics.ui.SearchUtil.tokenizeFilter;
+import static org.junit.Assert.assertEquals;
 
 /**
  * @author Bas Leijdekkers

MetricsReloaded/utils/src/main/java/org/jetbrains/research/groups/ml_methods/utils/PSIUtil.java

@@ -1,14 +1,18 @@
 package org.jetbrains.research.groups.ml_methods.utils;
 
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiMethod;
+import com.intellij.openapi.fileTypes.StdFileTypes;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.ProjectRootManager;
+import com.intellij.openapi.roots.TestSourcesFilter;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
-import java.util.HashSet;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
+
+import static com.sixrr.metrics.utils.MethodUtils.calculateSignature;
 
 public final class PSIUtil {
     private PSIUtil() {
@@ -87,4 +91,44 @@ public static boolean isOverriding(PsiMethod method) {
 
         return Optional.of(parent);
     }
+
+    public static String getHumanReadableName(@Nullable PsiElement element) {
+        if (element instanceof PsiMethod) {
+            return calculateSignature((PsiMethod) element);
+        } else if (element instanceof PsiClass) {
+            if (element instanceof PsiAnonymousClass) {
+                return getHumanReadableName(((PsiAnonymousClass) element).getBaseClassReference().resolve());
+            }
+            return ((PsiClass) element).getQualifiedName();
+        } else if (element instanceof PsiField) {
+            final PsiMember field = (PsiMember) element;
+            return getHumanReadableName(field.getContainingClass()) + "." + field.getName();
+        }
+        return "???";
+    }
+
+    public static List<VirtualFile> getAllJavaFiles(Project project, boolean includeTestSources) {
+        List<VirtualFile> javaVirtualFiles = new ArrayList<>();
+        ProjectRootManager projectRootManager = ProjectRootManager.getInstance(project);
+        projectRootManager.getFileIndex().iterateContent(virtualFile -> {
+            if (isJavaFile(virtualFile)) {
+                if (includeTestSources && TestSourcesFilter.isTestSources(virtualFile, project)) {
+                    javaVirtualFiles.add(virtualFile);
+                }
+                if (!TestSourcesFilter.isTestSources(virtualFile, project)) {
+                    javaVirtualFiles.add(virtualFile);
+                }
+            }
+            return true;
+        });
+        return javaVirtualFiles;
+    }
+
+    public static int getNumberOfJavaFiles(Project project, boolean includeTestSources) {
+        return getAllJavaFiles(project, includeTestSources).size();
+    }
+
+    public static boolean isJavaFile(VirtualFile virtualFile) {
+        return virtualFile.getFileType().equals(StdFileTypes.JAVA);
+    }
 }

algorithms-evaluation/src/main/java/org/jetbrains/research/groups/ml_methods/evaluation/AlgorithmEvaluator.java

@@ -5,9 +5,9 @@
 import com.sixrr.metrics.profile.MetricsProfile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.research.groups.ml_methods.algorithm.Algorithm;
+import org.jetbrains.research.groups.ml_methods.algorithm.RefactoringExecutionContext;
 import org.jetbrains.research.groups.ml_methods.refactoring.CalculatedRefactoring;
 import org.jetbrains.research.groups.ml_methods.refactoring.MoveToClassRefactoring;
-import org.jetbrains.research.groups.ml_methods.algorithm.RefactoringExecutionContext;
 import org.jetbrains.research.groups.ml_methods.utils.MetricsProfilesUtil;
 
 import java.util.Collections;

algorithms-evaluation/src/main/java/org/jetbrains/research/groups/ml_methods/evaluation/ProjectLoader.java

@@ -3,9 +3,9 @@
 import com.intellij.analysis.AnalysisScope;
 import com.intellij.openapi.project.Project;
 import com.sixrr.metrics.utils.ProjectUtils;
-import org.jetbrains.research.groups.ml_methods.refactoring.MoveToClassRefactoring;
 import org.jetbrains.research.groups.ml_methods.extraction.refactoring.RefactoringsLoader;
 import org.jetbrains.research.groups.ml_methods.extraction.refactoring.readers.RefactoringsReaders;
+import org.jetbrains.research.groups.ml_methods.refactoring.MoveToClassRefactoring;
 
 import java.io.IOException;
 import java.nio.file.Path;

core/src/main/java/org/jetbrains/research/groups/ml_methods/algorithm/ARI.java

@@ -6,13 +6,14 @@
 import com.sixrr.stockmetrics.classMetrics.NumMethodsClassMetric;
 import org.apache.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.research.groups.ml_methods.algorithm.AlgorithmsRepository.AlgorithmType;
 import org.jetbrains.research.groups.ml_methods.algorithm.attributes.*;
 import org.jetbrains.research.groups.ml_methods.algorithm.distance.DistanceCalculator;
 import org.jetbrains.research.groups.ml_methods.algorithm.distance.RelevanceBasedDistanceCalculator;
+import org.jetbrains.research.groups.ml_methods.logging.Logging;
 import org.jetbrains.research.groups.ml_methods.refactoring.CalculatedRefactoring;
 import org.jetbrains.research.groups.ml_methods.refactoring.MoveFieldRefactoring;
 import org.jetbrains.research.groups.ml_methods.refactoring.MoveMethodRefactoring;
-import org.jetbrains.research.groups.ml_methods.logging.Logging;
 import org.jetbrains.research.groups.ml_methods.utils.AlgorithmsUtil;
 
 import java.util.ArrayList;
@@ -27,7 +28,7 @@ public class ARI extends AbstractAlgorithm {
     private static final @NotNull DistanceCalculator distanceCalculator = RelevanceBasedDistanceCalculator.getInstance();
 
     public ARI() {
-        super("ARI", true);
+        super(AlgorithmType.ARI, true);
     }
 
     @Override

core/src/main/java/org/jetbrains/research/groups/ml_methods/algorithm/AbstractAlgorithm.java

@@ -7,9 +7,10 @@
 import org.apache.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.research.groups.ml_methods.algorithm.AlgorithmsRepository.AlgorithmType;
 import org.jetbrains.research.groups.ml_methods.algorithm.attributes.AttributesStorage;
-import org.jetbrains.research.groups.ml_methods.refactoring.CalculatedRefactoring;
 import org.jetbrains.research.groups.ml_methods.logging.Logging;
+import org.jetbrains.research.groups.ml_methods.refactoring.CalculatedRefactoring;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -35,12 +36,21 @@
 public abstract class AbstractAlgorithm implements Algorithm {
     private static final Logger LOGGER = Logging.getLogger(AbstractAlgorithm.class);
 
-    private final String name;
+    private final AlgorithmType algorithmType;
 
     private final boolean enableParallelExecution;
 
-    public AbstractAlgorithm(String name, boolean enableParallelExecution) {
-        this.name = name;
+    /**
+     * {@inheritDoc}
+     */
+    @NotNull
+    @Override
+    public AlgorithmType getAlgorithmType() {
+        return algorithmType;
+    }
+
+    public AbstractAlgorithm(AlgorithmType algorithmType, boolean enableParallelExecution) {
+        this.algorithmType = algorithmType;
         this.enableParallelExecution = enableParallelExecution;
     }
 
@@ -49,7 +59,7 @@ public AbstractAlgorithm(String name, boolean enableParallelExecution) {
      */
     @Override
     public @NotNull String getDescriptionString() {
-        return name;
+        return algorithmType.toString();
     }
 
     /**
@@ -61,7 +71,7 @@ public AbstractAlgorithm(String name, boolean enableParallelExecution) {
         final @Nullable ExecutorService service,
         final boolean enableFieldRefactorings
     ) {
-        LOGGER.info(name + " started");
+        LOGGER.info(algorithmType + " started");
         final long startTime = System.currentTimeMillis();
         final ProgressIndicator indicator;
 
@@ -72,7 +82,7 @@ public AbstractAlgorithm(String name, boolean enableParallelExecution) {
         }
 
         indicator.pushState();
-        indicator.setText("Running " + name + "...");
+        indicator.setText("Running " + algorithmType + "...");
         indicator.setFraction(0);
 
         final ExecutionContext context = new ExecutionContext(
@@ -87,16 +97,16 @@ public AbstractAlgorithm(String name, boolean enableParallelExecution) {
         } catch (ProcessCanceledException e) {
             throw e;
         } catch (Exception e) {
-            LOGGER.error(name + " finished with error: " + e);
-            return new AlgorithmResult(name, e);
+            LOGGER.error(algorithmType + " finished with error: " + e);
+            return new AlgorithmResult(algorithmType, e);
         }
 
         final long time = System.currentTimeMillis() - startTime;
         indicator.popState();
 
-        final AlgorithmResult result = new AlgorithmResult(refactorings, name, time, context.usedThreads);
+        final AlgorithmResult result = new AlgorithmResult(refactorings, algorithmType, time, context.usedThreads);
 
-        LOGGER.info(name + " successfully finished");
+        LOGGER.info(algorithmType + " successfully finished");
         LOGGER.info(result.getReport());
 
         return result;

core/src/main/java/org/jetbrains/research/groups/ml_methods/algorithm/Algorithm.java

@@ -8,6 +8,8 @@
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 
+import static org.jetbrains.research.groups.ml_methods.algorithm.AlgorithmsRepository.AlgorithmType;
+
 /**
  * An algorithm that analyses given {@link AttributesStorage} and produces refactoring suggestions
  * as an {@link AlgorithmResult}.
@@ -36,6 +38,11 @@ public interface Algorithm {
      */
     @NotNull String getDescriptionString();
 
+    /**
+     * Returns a type of algorithm. Should be used to identify algorithm and request it by enum type not by name.
+     */
+    @NotNull AlgorithmType getAlgorithmType();
+
     /**
      * Returns an array of metrics from which a features vectors for this particular algorithm
      * should be constructed.

core/src/main/java/org/jetbrains/research/groups/ml_methods/algorithm/AlgorithmResult.java

@@ -2,30 +2,31 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.research.groups.ml_methods.algorithm.AlgorithmsRepository.AlgorithmType;
 import org.jetbrains.research.groups.ml_methods.refactoring.CalculatedRefactoring;
 
 import java.util.Collections;
 import java.util.List;
 
 public class AlgorithmResult {
     private final List<CalculatedRefactoring> refactorings;
-    private final String algorithmName;
+    private final AlgorithmType algorithmType;
     private final long executionTime;
     private final int threadUsed;
     private final Exception exception;
 
-    AlgorithmResult(@NotNull List<CalculatedRefactoring> refactorings, String algorithmName, long executionTime,
+    AlgorithmResult(@NotNull List<CalculatedRefactoring> refactorings, AlgorithmType algorithmType, long executionTime,
                     int threadUsed) {
         this.refactorings = refactorings;
-        this.algorithmName = algorithmName;
+        this.algorithmType = algorithmType;
         this.executionTime = executionTime;
         this.threadUsed = threadUsed;
         this.exception = null;
     }
 
-    AlgorithmResult(String algorithmName, @NotNull Exception exception) {
+    AlgorithmResult(AlgorithmType algorithmType, @NotNull Exception exception) {
         this.refactorings = Collections.emptyList();
-        this.algorithmName = algorithmName;
+        this.algorithmType = algorithmType;
         this.executionTime = 0;
         this.threadUsed = 0;
         this.exception = exception;
@@ -35,8 +36,8 @@ public List<CalculatedRefactoring> getRefactorings() {
         return Collections.unmodifiableList(refactorings);
     }
 
-    public String getAlgorithmName() {
-        return algorithmName;
+    public AlgorithmType getAlgorithmType() {
+        return algorithmType;
     }
 
     public long getExecutionTime() {
@@ -57,7 +58,7 @@ public boolean isSuccess() {
     }
 
     public String getReport() {
-        return "Results of " + algorithmName + " running" + System.lineSeparator() +
+        return "Results of " + algorithmType + " running" + System.lineSeparator() +
                 "  Found " + refactorings.size() + " refactorings" + System.lineSeparator() +
                 "  Execution time: " + executionTime + System.lineSeparator() +
                 "  Threads used: " + threadUsed;

core/src/main/java/org/jetbrains/research/groups/ml_methods/algorithm/AlgorithmsRepository.java

@@ -17,6 +17,10 @@ public static Optional<Algorithm> getAlgorithmByName(String algorithmName) {
         return ALGORITHMS.stream().filter(algorithm -> algorithm.getDescriptionString().equals(algorithmName)).findAny();
     }
 
+    public enum AlgorithmType {
+        ARI, CCDA, HAC
+    }
+
     @Contract(pure = true)
     public static List<Algorithm> getAvailableAlgorithms() {
         return ALGORITHMS;

core/src/main/java/org/jetbrains/research/groups/ml_methods/algorithm/CCDA.java

@@ -5,15 +5,16 @@
 import com.sixrr.stockmetrics.classMetrics.NumMethodsClassMetric;
 import org.apache.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.research.groups.ml_methods.algorithm.AlgorithmsRepository.AlgorithmType;
 import org.jetbrains.research.groups.ml_methods.algorithm.attributes.AttributesStorage;
 import org.jetbrains.research.groups.ml_methods.algorithm.attributes.ClassAttributes;
 import org.jetbrains.research.groups.ml_methods.algorithm.attributes.ClassInnerEntityAttributes;
 import org.jetbrains.research.groups.ml_methods.algorithm.entity.*;
+import org.jetbrains.research.groups.ml_methods.logging.Logging;
 import org.jetbrains.research.groups.ml_methods.refactoring.CalculatedRefactoring;
 import org.jetbrains.research.groups.ml_methods.refactoring.MoveFieldRefactoring;
 import org.jetbrains.research.groups.ml_methods.refactoring.MoveMethodRefactoring;
 import org.jetbrains.research.groups.ml_methods.refactoring.MoveToClassRefactoring;
-import org.jetbrains.research.groups.ml_methods.logging.Logging;
 import org.jetbrains.research.groups.ml_methods.utils.AlgorithmsUtil;
 
 import java.util.*;
@@ -25,7 +26,7 @@ public class CCDA extends AbstractAlgorithm {
     private static final double ACCURACY = 1;
 
     public CCDA() {
-        super("CCDA", true);
+        super(AlgorithmType.CCDA, true);
 
     }