import java.util.LinkedList;
import java.util.List;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.ProjectWideExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.aspects.StatisticsAspect;
import no.uio.ifi.refaktor.aspects.StatisticsAspect.Statistics;
public class SearchBasedExtractAndMoveMethodAnalysisBenchmark extends AbstractSearchBasedExtractAndMoveMethodBenchmark {
- private List<ExtractAndMoveMethodAnalysisResult> results;
+ private List<ExtractAndMoveMethodCandidate> results;
@Test
public void bench() throws Throwable {
RefaktorDebug.log(t);
throw t;
} finally {
- results = new LinkedList<ExtractAndMoveMethodAnalysisResult>(analyzer.getResults());
+ results = new LinkedList<ExtractAndMoveMethodCandidate>(analyzer.getResults());
}
}
private void debugPrintFinalStatistics() {
Statistics snapshot = StatisticsAspect.aspectOf().getSnapshot();
- for (ExtractAndMoveMethodAnalysisResult result: results)
+ for (ExtractAndMoveMethodCandidate result: results)
RefaktorDebug.println(result);
RefaktorDebug.println("Number of results: " + results.size() + "\n");
import static org.junit.Assert.assertTrue;
import no.uio.ifi.refaktor.analyze.analyzers.Analyzer;
import no.uio.ifi.refaktor.analyze.analyzers.SearchBasedExtractAndMoveMethodAnalyzer;
-import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesAnalysisResultComparator;
+import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesCandidateComparator;
import no.uio.ifi.refaktor.analyze.exceptions.NoTargetFoundException;
import no.uio.ifi.refaktor.examples.manager.ExampleCodeManager;
import no.uio.ifi.refaktor.prefix.Prefix;
int methodOffset = method.getSourceRange().getOffset();
CompilationUnitTextSelection textSelection = new CompilationUnitTextSelection(method.getCompilationUnit(), methodOffset + 69, 10);
- assertThat(textSelection.isEquivalentTo(analyzer.getResult().textSelection));
+ assertThat(textSelection.isEquivalentTo(analyzer.getCandidate().textSelection));
ASTNode coveredNode = textSelection.getCoveredNode();
assertThat(coveredNode, instanceOf(ExpressionStatement.class));
MethodInvocation methodInvocation = (MethodInvocation) expressionStatement.getExpression();
Prefix prefix = new Prefix(methodInvocation);
- assertTrue(prefix.getVariableBindingOfFirstExpression().isEqualTo(analyzer.getResult().calculateOriginalTarget()));
+ assertTrue(prefix.getVariableBindingOfFirstExpression().isEqualTo(analyzer.getCandidate().calculateOriginalTarget()));
}
@Test
public void testSearchableMethodFavorNoUnfixes() throws Exception {
IMethod method = getTestDataMethod("searchableMethod");
- SearchBasedExtractAndMoveMethodAnalyzer analyzer = new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesAnalysisResultComparator());
+ SearchBasedExtractAndMoveMethodAnalyzer analyzer = new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesCandidateComparator());
analyzer.analyze();
int methodOffset = method.getSourceRange().getOffset();
CompilationUnitTextSelection textSelection = new CompilationUnitTextSelection(method.getCompilationUnit(), methodOffset + 100, 31);
- assertThat(textSelection.isEquivalentTo(analyzer.getResult().textSelection));
+ assertThat(textSelection.isEquivalentTo(analyzer.getCandidate().textSelection));
ASTNode coveredNode = textSelection.getCoveredNode();
assertThat(coveredNode, instanceOf(ExpressionStatement.class));
MethodInvocation methodInvocation = (MethodInvocation) expressionStatement.getExpression();
Prefix prefix = new Prefix(methodInvocation);
- assertTrue(prefix.getVariableBindingOfFirstExpression().isEqualTo(analyzer.getResult().calculateOriginalTarget()));
+ assertTrue(prefix.getVariableBindingOfFirstExpression().isEqualTo(analyzer.getCandidate().calculateOriginalTarget()));
}
@Test(expected=NoTargetFoundException.class)
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
-public class ExtractAndMoveMethodAnalysisResult {
- private class ResultDataCalculator {
+public class ExtractAndMoveMethodCandidate {
+ private class CandidateDataCalculator {
private final ExtractAndMoveMethodAnalyzer analyzer;
- public ResultDataCalculator(ExtractAndMoveMethodAnalyzer analyzer) {
+ public CandidateDataCalculator(ExtractAndMoveMethodAnalyzer analyzer) {
this.analyzer = analyzer;
}
private final boolean hasNoUnfixes;
private final String originalTargetKey;
- public ExtractAndMoveMethodAnalysisResult(IMethod method, ExtractAndMoveMethodAnalyzer analyzer, CompilationUnitTextSelection textSelection, int numberOfStatementsAnalyzed, int numberOfTextSelectionsAnalyzed) {
+ public ExtractAndMoveMethodCandidate(IMethod method, ExtractAndMoveMethodAnalyzer analyzer, CompilationUnitTextSelection textSelection, int numberOfStatementsAnalyzed, int numberOfTextSelectionsAnalyzed) {
this.method = method;
this.textSelection = new MethodRelativeCompilationUnitTextSelection(method, textSelection);
this.numberOfStatementsAnalyzed = numberOfStatementsAnalyzed;
this.numberOfTextSelectionsAnalyzed = numberOfTextSelectionsAnalyzed;
- ResultDataCalculator calculator = new ResultDataCalculator(analyzer);
+ CandidateDataCalculator calculator = new CandidateDataCalculator(analyzer);
hasMoreThanOnePossibleTarget = calculator.hasMoreThanOnePossibleTarget();
targetFrequency = calculator.getTargetFrequency();
hasNoUnfixes = calculator.hasNoUnfixes();
import java.util.LinkedList;
import java.util.List;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.utils.RefaktorDebug;
* Responsible for analyzing all methods in a compilation unit for
* candidates to the Extract and Move Method refactoring.
*/
-public class CompilationUnitWideExtractAndMoveMethodAnalyzer implements AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> {
+public class CompilationUnitWideExtractAndMoveMethodAnalyzer implements AggregationAnalyzer<ExtractAndMoveMethodCandidate> {
private final ICompilationUnit compilationUnit;
- private final List<ExtractAndMoveMethodAnalysisResult> results;
+ private final List<ExtractAndMoveMethodCandidate> results;
public CompilationUnitWideExtractAndMoveMethodAnalyzer(ICompilationUnit compilationUnit) {
this.compilationUnit = compilationUnit;
- results = new LinkedList<ExtractAndMoveMethodAnalysisResult>();
+ results = new LinkedList<ExtractAndMoveMethodCandidate>();
}
@Override
- public List<ExtractAndMoveMethodAnalysisResult> getResults() {
+ public List<ExtractAndMoveMethodCandidate> getResults() {
return results;
}
import java.util.LinkedList;
import java.util.List;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.utils.RefaktorDebug;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.JavaModelException;
-abstract public class PackageFragmentParentExtractAndMoveMethodAnalyzer implements AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> {
+abstract public class PackageFragmentParentExtractAndMoveMethodAnalyzer implements AggregationAnalyzer<ExtractAndMoveMethodCandidate> {
- private final List<ExtractAndMoveMethodAnalysisResult> results;
+ private final List<ExtractAndMoveMethodCandidate> results;
public PackageFragmentParentExtractAndMoveMethodAnalyzer() {
- results = new LinkedList<ExtractAndMoveMethodAnalysisResult>();
+ results = new LinkedList<ExtractAndMoveMethodCandidate>();
}
@Override
- public List<ExtractAndMoveMethodAnalysisResult> getResults() {
+ public List<ExtractAndMoveMethodCandidate> getResults() {
return results;
}
import java.util.LinkedList;
import java.util.List;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.utils.RefaktorDebug;
* Responsible for analyzing all methods in a package for
* candidates to the Extract and Move Method refactoring.
*/
-public class PackageWideExtractAndMoveMethodAnalyzer implements AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> {
+public class PackageWideExtractAndMoveMethodAnalyzer implements AggregationAnalyzer<ExtractAndMoveMethodCandidate> {
private final IPackageFragment packageFragment;
- private final List<ExtractAndMoveMethodAnalysisResult> results;
+ private final List<ExtractAndMoveMethodCandidate> results;
public PackageWideExtractAndMoveMethodAnalyzer(IPackageFragment packageFragment) {
this.packageFragment = packageFragment;
- results = new LinkedList<ExtractAndMoveMethodAnalysisResult>();
+ results = new LinkedList<ExtractAndMoveMethodCandidate>();
}
@Override
- public List<ExtractAndMoveMethodAnalysisResult> getResults() {
+ public List<ExtractAndMoveMethodCandidate> getResults() {
return results;
}
import java.util.LinkedList;
import java.util.Set;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
-import no.uio.ifi.refaktor.analyze.comparators.ExtractAndMoveMethodAnalysisResultComparator;
-import no.uio.ifi.refaktor.analyze.comparators.IgnorantAnalysisResultComparator;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.comparators.ExtractAndMoveMethodCandidateComparator;
+import no.uio.ifi.refaktor.analyze.comparators.IgnorantCandidateComparator;
import no.uio.ifi.refaktor.analyze.exceptions.GenericAnalyzerException;
import no.uio.ifi.refaktor.analyze.exceptions.NoTargetFoundException;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
public class SearchBasedExtractAndMoveMethodAnalyzer implements Analyzer {
private final IMethod method;
- private final ExtractAndMoveMethodAnalysisResultComparator analysisResultComparator;
- private final LinkedList<ExtractAndMoveMethodAnalysisResult> possibleResults;
+ private final ExtractAndMoveMethodCandidateComparator candidateComparator;
+ private final LinkedList<ExtractAndMoveMethodCandidate> candidates;
private final StatementListsCreator statementsCreator;
private Set<CompilationUnitTextSelection> textSelections;
- private ExtractAndMoveMethodAnalysisResult chosenResult;
+ private ExtractAndMoveMethodCandidate chosenCandidate;
public SearchBasedExtractAndMoveMethodAnalyzer(IMethod method) {
- this(method, new IgnorantAnalysisResultComparator());
+ this(method, new IgnorantCandidateComparator());
}
/**
* @param method The handle of the method to analyze.
- * @param analysisResultComparator A result comparator to compare two analysis results when deciding
+ * @param candidateComparator A candidate comparator to compare two analysis candidates when deciding
* which of them that is the best candidate for the refactoring.
*/
- public SearchBasedExtractAndMoveMethodAnalyzer(IMethod method, ExtractAndMoveMethodAnalysisResultComparator analysisResultComparator) {
+ public SearchBasedExtractAndMoveMethodAnalyzer(IMethod method, ExtractAndMoveMethodCandidateComparator candidateComparator) {
this.method = method;
- this.analysisResultComparator = analysisResultComparator;
- possibleResults = new LinkedList<ExtractAndMoveMethodAnalysisResult>();
+ this.candidateComparator = candidateComparator;
+ candidates = new LinkedList<ExtractAndMoveMethodCandidate>();
statementsCreator = new StatementListsCreator(method);
}
- public ExtractAndMoveMethodAnalysisResult getResult() {
- return chosenResult;
+ public ExtractAndMoveMethodCandidate getCandidate() {
+ return chosenCandidate;
}
@Override
try {
generateTextSelections();
- generatePossibleResults();
+ findPotentialCandidates();
} catch (RefaktorAnalyzerException e) {
throw new NoTargetFoundException(e);
}
- if (possibleResults.isEmpty())
+ if (candidates.isEmpty())
throw new NoTargetFoundException();
- chooseResult();
+ chooseCandidate();
}
private void abortIfStaticMethod() {
textSelections = TextSelectionsGenerator.generateTextSelections(statementsCreator, method.getCompilationUnit());
}
- private void generatePossibleResults() {
+ private void findPotentialCandidates() {
for (CompilationUnitTextSelection textSelection: textSelections) {
ExtractAndMoveMethodAnalyzer analyzer = new ExtractAndMoveMethodAnalyzer(textSelection);
analyzer.analyze();
if (analyzer.hasUsefulResults())
- possibleResults.add(new ExtractAndMoveMethodAnalysisResult(method, analyzer, textSelection, statementsCreator.getNumberOfStatements(), textSelections.size()));
+ candidates.add(new ExtractAndMoveMethodCandidate(method, analyzer, textSelection, statementsCreator.getNumberOfStatements(), textSelections.size()));
}
}
- private void chooseResult() {
- sortPossibleResults();
- chosenResult = possibleResults.getLast();
+ private void chooseCandidate() {
+ sortCandidates();
+ chosenCandidate = candidates.getLast();
}
- private void sortPossibleResults() {
- Collections.sort(possibleResults, analysisResultComparator);
+ private void sortCandidates() {
+ Collections.sort(candidates, candidateComparator);
}
}
\ No newline at end of file
import java.util.LinkedList;
import java.util.List;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
-import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesAnalysisResultComparator;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesCandidateComparator;
import no.uio.ifi.refaktor.analyze.exceptions.NoTargetFoundException;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.utils.RefaktorDebug;
* Responsible for analyzing all methods in a type for
* candidates to the Extract and Move Method refactoring.
*/
-public class TypeWideExtractAndMoveMethodAnalyzer implements AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> {
+public class TypeWideExtractAndMoveMethodAnalyzer implements AggregationAnalyzer<ExtractAndMoveMethodCandidate> {
private final IType type;
- private final List<ExtractAndMoveMethodAnalysisResult> results;
+ private final List<ExtractAndMoveMethodCandidate> candidates;
public TypeWideExtractAndMoveMethodAnalyzer(IType type) {
this.type = type;
- results = new LinkedList<ExtractAndMoveMethodAnalysisResult>();
+ candidates = new LinkedList<ExtractAndMoveMethodCandidate>();
}
@Override
- public List<ExtractAndMoveMethodAnalysisResult> getResults() {
- return results;
+ public List<ExtractAndMoveMethodCandidate> getResults() {
+ return candidates;
}
@Override
private void analyzeMethod(IMethod method) {
try {
SearchBasedExtractAndMoveMethodAnalyzer analyzer =
- new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesAnalysisResultComparator());
+ new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesCandidateComparator());
analyzer.analyze();
- results.add(analyzer.getResult());
+ candidates.add(analyzer.getCandidate());
} catch (NoTargetFoundException e) {
// Ignoring
} catch (AssertionError err) {
+++ /dev/null
-package no.uio.ifi.refaktor.analyze.comparators;
-
-import java.util.Comparator;
-
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
-
-/**
- * The {@link ExtractAndMoveMethodAnalysisResult} that is to be favored
- * must be greater in comparison to a result that is less preferred.
- */
-public interface ExtractAndMoveMethodAnalysisResultComparator extends Comparator<ExtractAndMoveMethodAnalysisResult>{
-
-}
\ No newline at end of file
--- /dev/null
+package no.uio.ifi.refaktor.analyze.comparators;
+
+import java.util.Comparator;
+
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
+
+/**
+ * The {@link ExtractAndMoveMethodCandidate} that is to be favored
+ * must be greater in comparison to a result that is less preferred.
+ */
+public interface ExtractAndMoveMethodCandidateComparator extends Comparator<ExtractAndMoveMethodCandidate>{
+
+}
\ No newline at end of file
package no.uio.ifi.refaktor.analyze.comparators;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
-public final class FavorNoUnfixesAnalysisResultComparator implements ExtractAndMoveMethodAnalysisResultComparator {
+public final class FavorNoUnfixesCandidateComparator implements ExtractAndMoveMethodCandidateComparator {
@Override
- public int compare(ExtractAndMoveMethodAnalysisResult resultOne, ExtractAndMoveMethodAnalysisResult resultTwo) {
+ public int compare(ExtractAndMoveMethodCandidate resultOne, ExtractAndMoveMethodCandidate resultTwo) {
if (resultOne.hasNoUnfixes() && resultTwo.hasUnfixes())
return 1;
else if (resultOne.hasUnfixes() && resultTwo.hasNoUnfixes())
+++ /dev/null
-package no.uio.ifi.refaktor.analyze.comparators;
-
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
-
-
-/**
- * An ignorant {@link ExtractAndMoveMethodAnalysisResultComparator}
- * that compares all analysis results to be equal.
- */
-public class IgnorantAnalysisResultComparator implements ExtractAndMoveMethodAnalysisResultComparator {
-
- @Override
- public int compare(ExtractAndMoveMethodAnalysisResult o1, ExtractAndMoveMethodAnalysisResult o2) {
- return 0;
- }
-
-}
--- /dev/null
+package no.uio.ifi.refaktor.analyze.comparators;
+
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
+
+
+/**
+ * An ignorant {@link ExtractAndMoveMethodCandidateComparator}
+ * that compares all analysis results to be equal.
+ */
+public class IgnorantCandidateComparator implements ExtractAndMoveMethodCandidateComparator {
+
+ @Override
+ public int compare(ExtractAndMoveMethodCandidate o1, ExtractAndMoveMethodCandidate o2) {
+ return 0;
+ }
+
+}
package no.uio.ifi.refaktor.aspects;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.reports.Report;
import org.eclipse.jdt.core.dom.IVariableBinding;
public class ExtractAndMoveMethodExecutionResult {
- private final ExtractAndMoveMethodAnalysisResult analysisResult;
+ private final ExtractAndMoveMethodCandidate analysisResult;
private final String signatureOfExtractedMethod;
private final String originalTargetString;
private final int executionNumber;
- public ExtractAndMoveMethodExecutionResult(int executionNumber, ExtractAndMoveMethodAnalysisResult analysisResult,
+ public ExtractAndMoveMethodExecutionResult(int executionNumber, ExtractAndMoveMethodCandidate analysisResult,
String signatureOfExtractedMethod, IVariableBinding originalTarget) {
this.executionNumber = executionNumber;
this.analysisResult = analysisResult;
import java.util.List;
import java.util.Map;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.CompilationUnitWideExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.ExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.SearchBasedExtractAndMoveMethodAnalyzer;
call(* ExtractAndMoveMethodExecutor.execute(..)) && target(executor);
pointcut analysisResultCreated() :
- call(public ExtractAndMoveMethodAnalysisResult.new(..));
+ call(public ExtractAndMoveMethodCandidate.new(..));
after() : selectionAnalyze() {
statistics.selectionsAnalyzedCount++;
package no.uio.ifi.refaktor.change.changers;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.change.exceptions.RefactoringNotExecutedException;
*/
public class AggregationAnalyzerChanger implements RefaktorChanger {
- private AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> analyzer;
+ private AggregationAnalyzer<ExtractAndMoveMethodCandidate> analyzer;
- public AggregationAnalyzerChanger(AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> analyzer) {
+ public AggregationAnalyzerChanger(AggregationAnalyzer<ExtractAndMoveMethodCandidate> analyzer) {
this.analyzer = analyzer;
}
@Override
public void execute(IProgressMonitor monitor) throws CoreException {
- for (ExtractAndMoveMethodAnalysisResult result: analyzer.getResults()) {
+ for (ExtractAndMoveMethodCandidate result: analyzer.getResults()) {
try {
RefaktorDebug.println();
RefaktorDebug.println(this, result);
package no.uio.ifi.refaktor.change.changers;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.ProjectWideExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.change.executors.ExtractAndMoveMethodExecutor;
/**
* A {@link RefaktorChanger} that is responsible for analyzing all of the methods
* in a project and execute the {@link ExtractAndMoveMethodExecutor} on all of the
- * positive results from the analysis. See {@link ExtractAndMoveMethodAnalysisResult}.
+ * positive results from the analysis. See {@link ExtractAndMoveMethodCandidate}.
*
* This is done with the help of a {@link ProjectWideExtractAndMoveMethodAnalyzer}
* and an {@link AggregationAnalyzerChanger}.
package no.uio.ifi.refaktor.change.changers;
import no.uio.ifi.refaktor.analyze.analyzers.SearchBasedExtractAndMoveMethodAnalyzer;
-import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesAnalysisResultComparator;
+import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesCandidateComparator;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.change.executors.ExtractAndMoveMethodExecutor;
private SearchBasedExtractAndMoveMethodAnalyzer analyzer;
public SearchBasedExtractAndMoveMethodChanger(IMethod method) {
- this.analyzer = new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesAnalysisResultComparator());
+ this.analyzer = new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesCandidateComparator());
}
@Override
@Override
public void execute(IProgressMonitor monitor) throws CoreException {
- ExtractAndMoveMethodExecutor executor = new ExtractAndMoveMethodExecutor(analyzer.getResult());
+ ExtractAndMoveMethodExecutor executor = new ExtractAndMoveMethodExecutor(analyzer.getCandidate());
executor.execute(new NullProgressMonitor());
}
package no.uio.ifi.refaktor.change.executors;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.change.exceptions.RefactoringNotExecutedException;
import no.uio.ifi.refaktor.utils.CompilationUnitTextSelection;
/**
* This {@link Executor} composes the refactorings known as 'Extract Method' and 'Move Method'.
*
- * It takes the result of an analysis (see {@link ExtractAndMoveMethodAnalysisResult})
+ * It takes the result of an analysis (see {@link ExtractAndMoveMethodCandidate})
* and uses its textSelection, new method name and original target. First it executes
* an {@link ExtractMethodRefactoringExecutor} and then a
* {@link MoveMethodRefactoringExecutor}.
private final CompilationUnitTextSelection textSelection;
private final IVariableBinding originalTarget;
private String newMethodName;
- private ExtractAndMoveMethodAnalysisResult analysisResult;
+ private ExtractAndMoveMethodCandidate analysisResult;
private ExtractMethodPostExecutionResources postExecutionResources;
private IProgressMonitor monitor;
- public ExtractAndMoveMethodExecutor(ExtractAndMoveMethodAnalysisResult analysisResult) {
+ public ExtractAndMoveMethodExecutor(ExtractAndMoveMethodCandidate analysisResult) {
this(analysisResult.textSelection, analysisResult.getNewMethodName(), analysisResult.calculateOriginalTarget());
this.analysisResult = analysisResult;
}
package no.uio.ifi.refaktor.handlers;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
import no.uio.ifi.refaktor.aspects.StatisticsAspect;
import no.uio.ifi.refaktor.aspects.StatisticsAspect.Statistics;
public abstract class AbstractSearchBasedExtractAndMoveMethodHandler extends AbstractHandler {
- protected abstract AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> createAnalyzer(Object element);
+ protected abstract AggregationAnalyzer<ExtractAndMoveMethodCandidate> createAnalyzer(Object element);
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
StatisticsAspect.init();
- AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> analyzer = createAnalyzer(element);
+ AggregationAnalyzer<ExtractAndMoveMethodCandidate> analyzer = createAnalyzer(element);
analyzer.analyze();
Statistics statistics = StatisticsAspect.getSnapshot();
package no.uio.ifi.refaktor.handlers;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.CompilationUnitWideExtractAndMoveMethodAnalyzer;
public class CompilationUnitWideSearchBasedExtractAndMoveMethodAnalysisHandler extends AbstractSearchBasedExtractAndMoveMethodHandler {
@Override
- protected AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> createAnalyzer(Object element) {
+ protected AggregationAnalyzer<ExtractAndMoveMethodCandidate> createAnalyzer(Object element) {
assert element instanceof ICompilationUnit;
ICompilationUnit compilationUnit = (ICompilationUnit) element;
return new CompilationUnitWideExtractAndMoveMethodAnalyzer(compilationUnit);
package no.uio.ifi.refaktor.handlers;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.PackageFragmentRootWideExtractAndMoveMethodAnalyzer;
public class PackageFragmentRootWideSearchBasedExtractAndMoveMethodAnalysisHandler extends AbstractSearchBasedExtractAndMoveMethodHandler {
@Override
- protected AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> createAnalyzer(Object element) {
+ protected AggregationAnalyzer<ExtractAndMoveMethodCandidate> createAnalyzer(Object element) {
assert element instanceof IPackageFragmentRoot;
IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) element;
return new PackageFragmentRootWideExtractAndMoveMethodAnalyzer(packageFragmentRoot);
package no.uio.ifi.refaktor.handlers;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.PackageWideExtractAndMoveMethodAnalyzer;
public class PackageWideSearchBasedExtractAndMoveMethodAnalysisHandler extends AbstractSearchBasedExtractAndMoveMethodHandler {
@Override
- protected AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> createAnalyzer(Object element) {
+ protected AggregationAnalyzer<ExtractAndMoveMethodCandidate> createAnalyzer(Object element) {
assert element instanceof IPackageFragment;
IPackageFragment packageFragment = (IPackageFragment) element;
return new PackageWideExtractAndMoveMethodAnalyzer(packageFragment);
package no.uio.ifi.refaktor.handlers;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.ProjectWideExtractAndMoveMethodAnalyzer;
public class ProjectWideSearchBasedExtractAndMoveMethodAnalysisHandler extends AbstractSearchBasedExtractAndMoveMethodHandler {
@Override
- protected AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> createAnalyzer(Object element) {
+ protected AggregationAnalyzer<ExtractAndMoveMethodCandidate> createAnalyzer(Object element) {
assert element instanceof IProject || element instanceof IJavaProject;
if (element instanceof IProject)
package no.uio.ifi.refaktor.handlers;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.SearchBasedExtractAndMoveMethodAnalyzer;
-import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesAnalysisResultComparator;
+import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesCandidateComparator;
import no.uio.ifi.refaktor.analyze.exceptions.NoTargetFoundException;
import org.eclipse.core.commands.AbstractHandler;
String message = "";
try {
- SearchBasedExtractAndMoveMethodAnalyzer analyzer = new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesAnalysisResultComparator());
+ SearchBasedExtractAndMoveMethodAnalyzer analyzer = new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesCandidateComparator());
analyzer.analyze();
- ExtractAndMoveMethodAnalysisResult result = analyzer.getResult();
+ ExtractAndMoveMethodCandidate result = analyzer.getCandidate();
message = "Result:\n\nText selection:\n" + result.textSelection
+ "\n\nNumber of text selections analyzed:\n" + result.numberOfTextSelectionsAnalyzed
+ "\n\nOriginal target:\n" + result.calculateOriginalTarget()
package no.uio.ifi.refaktor.handlers;
-import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
+import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.TypeWideExtractAndMoveMethodAnalyzer;
public class TypeWideSearchBasedExtractAndMoveMethodAnalysisHandler extends AbstractSearchBasedExtractAndMoveMethodHandler {
@Override
- protected AggregationAnalyzer<ExtractAndMoveMethodAnalysisResult> createAnalyzer(Object element) {
+ protected AggregationAnalyzer<ExtractAndMoveMethodCandidate> createAnalyzer(Object element) {
assert element instanceof IType;
IType type = (IType) element;
return new TypeWideExtractAndMoveMethodAnalyzer(type);