--- /dev/null
+package no.uio.ifi.refaktor.tests;
+
+import static no.uio.ifi.refaktor.tests.assertion.RefaktorAssert.assertThat;
+import static org.junit.Assert.fail;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
+import no.uio.ifi.refaktor.change.changers.ProjectWideExtractLocalVariableChanger;
+import no.uio.ifi.refaktor.change.changers.RefaktorChanger;
+import no.uio.ifi.refaktor.examples.manager.ExampleCodeManager;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ProjectWideExtractLocalVariableChangerTest {
+
+ interface Setup {
+ RefaktorChanger setup() throws CoreException;
+ }
+
+ @Parameters
+ public static Collection<Object[]> data() throws CoreException {
+ return Arrays.asList(new Object[][] {
+ /* [stolz] Defer execution until Example-project extracted */
+// { new Setup() { public RefaktorChanger setup() throws CoreException {
+// return new ProjectWideExtractAndMoveMethodChanger(ExampleCodeManager.INSTANCE.getProject());}
+// } }
+ /* Test with the next line to check that repeated execution indeed always works on a fresh workspace: */
+ /* Anna's refactoring with the same API goes here: */
+ { new Setup() { public RefaktorChanger setup() throws CoreException {return new ProjectWideExtractLocalVariableChanger(ExampleCodeManager.INSTANCE.getProject());}} }
+
+ });
+ }
+
+ @Parameter
+ public Setup setup;
+
+ @Test
+ public void testAnalyzeAndChange() throws CoreException {
+ ExampleCodeManager.INSTANCE.loadExampleCode(); // could be in setup() as well.
+ RefaktorChanger changer = setup.setup();
+ try {
+ changer.checkPreconditions();
+ changer.execute(new NullProgressMonitor());
+ } catch (RefaktorAnalyzerException e) {
+ fail("Preconditions failed to validate.");
+ } catch (CoreException e) {
+ fail("Execution failed.");
+ }
+
+ ExampleCodeManager.INSTANCE.cleanBuild();
+ assertThat("Project has errors after change.", !ExampleCodeManager.INSTANCE.projectHasErrors());
+ }
+}
}
private void analyzeMethodsInType(IType type) throws JavaModelException {
- TypeWideExtractAndMoveMethodAnalyzer analyzer = new TypeWideExtractAndMoveMethodAnalyzer(type);
+ TypeWideRefactorAnalyzer analyzer = new TypeWideRefactorAnalyzer(type);
analyzer.analyze();
results.addAll(analyzer.getResults());
}
--- /dev/null
+package no.uio.ifi.refaktor.analyze.analyzers;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
+import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
+import no.uio.ifi.refaktor.debugging.RefaktorDebug;
+
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+
+/**
+ * Responsible for analyzing all methods in a compilation unit for
+ * candidates to the Extract and Move Method refactoring.
+ */
+public class CompilationUnitWideRefactorAnalyzer<Candidate extends RefactorCandidate> implements AggregationAnalyzer<Candidate> {
+
+ private final ICompilationUnit compilationUnit;
+ private final List<Candidate> results;
+
+ public CompilationUnitWideRefactorAnalyzer(ICompilationUnit compilationUnit) {
+ this.compilationUnit = compilationUnit;
+ results = new LinkedList<Candidate>();
+ }
+
+ @Override
+ public List<Candidate> getResults() {
+ return results;
+ }
+
+ @Override
+ public void analyze() throws RefaktorAnalyzerException {
+ try {
+ analyzeMethodsInCompilationUnit();
+ } catch (JavaModelException e) {
+ RefaktorDebug.log(e);
+ }
+ }
+
+ private void analyzeMethodsInCompilationUnit() throws JavaModelException {
+ for (IType type: compilationUnit.getAllTypes())
+ analyzeMethodsInType(type);
+ }
+
+ private void analyzeMethodsInType(IType type) throws JavaModelException {
+ TypeWideRefactorAnalyzer<Candidate> analyzer = new TypeWideRefactorAnalyzer<Candidate>(type);
+ analyzer.analyze();
+ results.addAll(analyzer.getResults());
+ }
+}
--- /dev/null
+package no.uio.ifi.refaktor.analyze.analyzers;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
+import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
+import no.uio.ifi.refaktor.debugging.RefaktorDebug;
+
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.JavaModelException;
+
+abstract public class PackageFragmentParentRefactoringAnalyzer<Candidate extends RefactorCandidate> implements AggregationAnalyzer<ExtractAndMoveMethodCandidate> {
+
+ private final List<ExtractAndMoveMethodCandidate> results;
+
+ public PackageFragmentParentRefactoringAnalyzer() {
+ results = new LinkedList<ExtractAndMoveMethodCandidate>();
+ }
+
+ @Override
+ public List<ExtractAndMoveMethodCandidate> getResults() {
+ return results;
+ }
+
+ @Override
+ public void analyze() throws RefaktorAnalyzerException {
+ try {
+ analyzeMethodsInPackages();
+ } catch (JavaModelException e) {
+ RefaktorDebug.log(e);
+ }
+ }
+
+ protected abstract List<IPackageFragment> getPackages() throws JavaModelException;
+
+ private void analyzeMethodsInPackages() throws JavaModelException {
+ for (IPackageFragment packageFragment: getPackages()) {
+ analyzeMethodsInPackage(packageFragment);
+ }
+ }
+
+ private void analyzeMethodsInPackage(IPackageFragment packageFragment) throws JavaModelException {
+ PackageWideExtractAndMoveMethodAnalyzer analyzer =
+ new PackageWideExtractAndMoveMethodAnalyzer(packageFragment);
+ analyzer.analyze();
+ results.addAll(analyzer.getResults());
+ }
+}
\ No newline at end of file
--- /dev/null
+package no.uio.ifi.refaktor.analyze.analyzers;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
+import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
+import no.uio.ifi.refaktor.debugging.RefaktorDebug;
+
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.JavaModelException;
+
+/**
+ * Responsible for analyzing all methods in a package for
+ * candidates to the Extract and Move Method refactoring.
+ */
+public class PackageWideExtractLocalVariableAnalyzer implements AggregationAnalyzer<ExtractLocalVariableCandidate> {
+
+ private final IPackageFragment packageFragment;
+ private final List<ExtractLocalVariableCandidate> results;
+
+ public PackageWideExtractLocalVariableAnalyzer(IPackageFragment packageFragment) {
+ this.packageFragment = packageFragment;
+ results = new LinkedList<ExtractLocalVariableCandidate>();
+ }
+
+ @Override
+ public List<ExtractLocalVariableCandidate> getResults() {
+ return results;
+ }
+
+ @Override
+ public void analyze() throws RefaktorAnalyzerException {
+ try {
+ analyzeMethodsInPackage();
+ } catch (JavaModelException e) {
+ RefaktorDebug.log(e);
+ }
+ }
+
+ private void analyzeMethodsInPackage() throws JavaModelException {
+ for (ICompilationUnit compilationUnit: packageFragment.getCompilationUnits())
+ analyzeMethodsInCompilationUnit(compilationUnit);
+ }
+
+ private void analyzeMethodsInCompilationUnit(ICompilationUnit compilationUnit) {
+ CompilationUnitWideRefactorAnalyzer analyzer =
+ new CompilationUnitWideRefactorAnalyzer(compilationUnit);
+ analyzer.analyze();
+ results.addAll(analyzer.getResults());
+ }
+}
--- /dev/null
+package no.uio.ifi.refaktor.analyze.analyzers;
+
+import java.util.Arrays;
+import java.util.List;
+
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
+import no.uio.ifi.refaktor.utils.RefaktorHandleUtils;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.JavaModelException;
+
+/**
+ * Responsible for analyzing all methods in a project for
+ * candidates to the Extract Temp refactoring
+ *
+ * @author Anna Eilertsen
+ */
+public class ProjectWideRefactoringAnalyzer<Candidate extends RefactorCandidate> extends PackageFragmentParentRefactoringAnalyzer<Candidate> {
+
+ private final IJavaProject javaProject;
+
+ public ProjectWideRefactoringAnalyzer(IProject project) {
+ this(RefaktorHandleUtils.createJavaProjectFrom(project));
+ }
+
+ public ProjectWideRefactoringAnalyzer(IJavaProject javaProject) {
+ this.javaProject = javaProject;
+ }
+
+ @Override
+ protected List<IPackageFragment> getPackages() throws JavaModelException {
+ return RefaktorHandleUtils.findPackagesAmongPackageFragments(Arrays.asList(javaProject.getPackageFragments()));
+ }
+}
-package no.uio.ifi.refaktor.analyze;
+package no.uio.ifi.refaktor.analyze.analyzers;
import java.util.Collections;
+import java.util.Comparator;
import java.util.LinkedList;
import java.util.Set;
import org.eclipse.jdt.core.IMethod;
-import no.uio.ifi.refaktor.analyze.analyzers.Analyzer;
-import no.uio.ifi.refaktor.analyze.analyzers.ExtractLocalVariableSelectionAnalyzer;
-import no.uio.ifi.refaktor.analyze.analyzers.StatementListsCreator;
-import no.uio.ifi.refaktor.analyze.analyzers.TextSelectionsGenerator;
import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
-import no.uio.ifi.refaktor.analyze.comparators.ExtractLocalVariableCandidateComparator;
-import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesExtractLocalVariableCandidateComparator;
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
+import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesComparator;
import no.uio.ifi.refaktor.analyze.exceptions.NoTargetFoundException;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
+import no.uio.ifi.refaktor.factories.RefactoringFactory;
import no.uio.ifi.refaktor.textselection.CompilationUnitTextSelection;
/**
*
* This class uses the {@link ExtractLocalVariableSelectionAnalyzer} class to analyze each potential selection.
*
+ * TODO I'm using a factory pattern that I don't really know how to use. Ask Volker. For now this is a
+ * hybrid pattern class.
+ *
* @author Anna Eilertsen
*
*/
-public class SearchBasedExtractLocalVariableAnalyzer implements Analyzer{
+public class SearchBasedRefactoringAnalyzer<Candidate extends RefactorCandidate> implements Analyzer{
private IMethod method;
- private ExtractLocalVariableCandidateComparator candidateComparator;
- private LinkedList<ExtractLocalVariableCandidate> candidates;
+ private Comparator<Candidate> candidateComparator;
+ private LinkedList<RefactorCandidate> candidates;
private StatementListsCreator statementsCreator;
private Set<CompilationUnitTextSelection> textSelections;
private ExtractLocalVariableCandidate chosenCandidate;
- public SearchBasedExtractLocalVariableAnalyzer(IMethod method,
- FavorNoUnfixesExtractLocalVariableCandidateComparator favorNoUnfixesCandidateComparator) {
+ public SearchBasedRefactoringAnalyzer(RefactoringFactory<Candidate> factory, IMethod method,
+ FavorNoUnfixesComparator<Candidate> comparator) {
this.method = method;
- this.candidateComparator = favorNoUnfixesCandidateComparator;
- candidates = new LinkedList<ExtractLocalVariableCandidate>();
+ this.candidateComparator = comparator;
+ candidates = new LinkedList<RefactorCandidate>();
statementsCreator = new StatementListsCreator(method);
}
ExtractLocalVariableSelectionAnalyzer analyzer = new ExtractLocalVariableSelectionAnalyzer(textSelection);
analyzer.analyze();
+ Candidate c;
+
if (analyzer.hasUsefulResults())
- candidates.add(new ExtractLocalVariableCandidate(method, analyzer, textSelection, statementsCreator.getNumberOfStatements(), textSelections.size()));
+ candidates.add(RefactoringFactory.getInstance(c.getClass(), method, analyzer, textSelection, statementsCreator.getNumberOfStatements(), textSelections.size()));
}
}
import java.util.List;
import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesExtractAndMoveCandidateComparator;
+import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesComparator;
import no.uio.ifi.refaktor.analyze.exceptions.NoTargetFoundException;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.debugging.RefaktorDebug;
* Responsible for analyzing all methods in a type for
* candidates to the Extract and Move Method refactoring.
*/
-public class TypeWideExtractAndMoveMethodAnalyzer implements AggregationAnalyzer<ExtractAndMoveMethodCandidate> {
+public class TypeWideRefactorAnalyzer<Candidate extends RefactorCandidate> implements AggregationAnalyzer<ExtractAndMoveMethodCandidate> {
private final IType type;
- private final List<ExtractAndMoveMethodCandidate> candidates;
+ private final List<Candidate> candidates;
- public TypeWideExtractAndMoveMethodAnalyzer(IType type) {
+ public TypeWideRefactorAnalyzer(IType type) {
this.type = type;
- candidates = new LinkedList<ExtractAndMoveMethodCandidate>();
+ candidates = new LinkedList<Candidate>();
}
@Override
- public List<ExtractAndMoveMethodCandidate> getResults() {
+ public List<Candidate> getResults() {
return candidates;
}
private void analyzeMethod(IMethod method) {
try {
SearchBasedExtractAndMoveMethodAnalyzer analyzer =
- new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesExtractAndMoveCandidateComparator());
+ new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesComparator());
analyzer.analyze();
candidates.add(analyzer.getCandidate());
} catch (NoTargetFoundException e) {
package no.uio.ifi.refaktor.analyze.candidates;
+import no.uio.ifi.refaktor.textselection.CompilationUnitTextSelection;
+
/**
* Represents candidate for a refactoring,
* i.e. a selection, found in a method, that can be the input of a refactoring command
* @return true if the represented selection contains no unfixes (unsafe prefixes), false otherwise
*/
public boolean hasNoUnfixes();
+
+ /**
+ *
+ * @return The text selection that will be the argument of the refactoring
+ */
+ public CompilationUnitTextSelection getTextSelection();
+
+ /**
+ * TODO What specifically is meant by Target?
+ *
+ * @return true if only one possible target, false otherwise
+ */
+ public boolean hasOnlyOnePossibleTarget();
+
+ /**
+ *
+ * @return true if more than one possible target
+ */
+ public boolean hasMoreThanOnePossibleTarget();
+
+ /**
+ *
+ * @return target frequency
+ */
+ public int getTargetFrequency();
+
+ /**
+ * ex
+ * target x.c.x has segment count 3
+ *
+ * @return target prefix segment count
+ */
+ public int getTargetPrefixSegmentCount();
}
+++ /dev/null
-package no.uio.ifi.refaktor.analyze.comparators;
-
-import java.util.Comparator;
-
-import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
-
-public interface ExtractLocalVariableCandidateComparator extends Comparator<ExtractLocalVariableCandidate>{
-
-}
*/
package no.uio.ifi.refaktor.analyze.comparators;
-import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
+import java.util.Comparator;
+
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
/**
+ * Generic comparator
+ *
* @author Anna Eilertsen
*
*/
-public class FavorNoUnfixesExtractLocalVariableCandidateComparator implements ExtractLocalVariableCandidateComparator {
+public class FavorNoUnfixesComparator<Candidate extends RefactorCandidate> implements Comparator<Candidate> {
@Override
- public int compare(ExtractLocalVariableCandidate resultOne, ExtractLocalVariableCandidate resultTwo) {
+ public int compare(Candidate resultOne, Candidate resultTwo) {
if (resultOne.hasNoUnfixes() && resultTwo.hasUnfixes())
return 1;
else if (resultOne.hasUnfixes() && resultTwo.hasNoUnfixes())
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IMethod;
-import no.uio.ifi.refaktor.analyze.SearchBasedExtractLocalVariableAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.SearchBasedExtractAndMoveMethodAnalyzer;
+import no.uio.ifi.refaktor.analyze.analyzers.SearchBasedRefactoringAnalyzer;
import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesExtractAndMoveCandidateComparator;
-import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesExtractLocalVariableCandidateComparator;
+import no.uio.ifi.refaktor.analyze.comparators.FavorNoUnfixesComparator;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.change.changers.RefaktorChanger;
import no.uio.ifi.refaktor.change.executors.ExtractAndMoveMethodExecutor;
-import no.uio.ifi.refaktor.change.executors.ExtractLocalVariableExecutor;
+import no.uio.ifi.refaktor.change.executors.RefactoringExecutor;
public class SearchBasedExtractLocalVariableWithAssertsChanger implements RefaktorChanger {
- private SearchBasedExtractLocalVariableAnalyzer analyzer;
+ private SearchBasedRefactoringAnalyzer analyzer;
public SearchBasedExtractLocalVariableWithAssertsChanger(IMethod method) {
- this.analyzer = new SearchBasedExtractLocalVariableAnalyzer(method, new FavorNoUnfixesExtractLocalVariableCandidateComparator());
+ this.analyzer = new SearchBasedRefactoringAnalyzer(method, new FavorNoUnfixesComparator());
}
@Override
@Override
public void execute(IProgressMonitor monitor) throws CoreException {
- ExtractLocalVariableExecutor executor = new ExtractLocalVariableExecutor(analyzer.getCandidate());
+ RefactoringExecutor executor = new RefactoringExecutor(analyzer.getCandidate());
executor.execute(monitor);
}
import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.change.exceptions.RefactoringNotExecutedException;
import no.uio.ifi.refaktor.change.exceptions.RefaktorChangerException;
import no.uio.ifi.refaktor.change.executors.ExtractAndMoveMethodExecutor;
+import no.uio.ifi.refaktor.change.executors.RefactoringExecutor;
import no.uio.ifi.refaktor.debugging.RefaktorDebug;
import org.eclipse.core.runtime.CoreException;
/**
* A {@link RefaktorChanger} that is responsible for running an
* {@link AggregationAnalyzer} and executing the
- * {@link ExtractAndMoveMethodExecutor} on all results returned from it.
+ * {@link RefactoringExecutor} on all results returned from it.
+ *
+ * Generic class for use with different Refactorings
+ *
+ * @author Anna Eilertsen
*/
-public class AggregationAnalyzerChanger implements RefaktorChanger {
+public class AggregationAnalyzerChanger<Candidate extends RefactorCandidate> implements RefaktorChanger {
- private AggregationAnalyzer<ExtractAndMoveMethodCandidate> analyzer;
+ private AggregationAnalyzer<Candidate> analyzer;
- public AggregationAnalyzerChanger(AggregationAnalyzer<ExtractAndMoveMethodCandidate> analyzer) {
+ public AggregationAnalyzerChanger(AggregationAnalyzer<Candidate> analyzer) {
this.analyzer = analyzer;
}
@Override
public void execute(IProgressMonitor monitor) throws CoreException {
- for (ExtractAndMoveMethodCandidate result: analyzer.getResults()) {
+ for (Candidate result: analyzer.getResults()) {
try {
RefaktorDebug.println();
RefaktorDebug.println(this, result);
- ExtractAndMoveMethodExecutor executor = new ExtractAndMoveMethodExecutor(result);
+ RefactoringExecutor<Candidate> executor = new RefactoringExecutor<Candidate>(result);
executor.execute(new NullProgressMonitor());
} catch (RefactoringNotExecutedException e) {
RefaktorDebug.log(e);
--- /dev/null
+package no.uio.ifi.refaktor.change.changers;
+
+import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
+import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
+import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
+import no.uio.ifi.refaktor.change.exceptions.RefactoringNotExecutedException;
+import no.uio.ifi.refaktor.change.exceptions.RefaktorChangerException;
+import no.uio.ifi.refaktor.change.executors.ExtractAndMoveMethodExecutor;
+import no.uio.ifi.refaktor.debugging.RefaktorDebug;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+
+/**
+ * A {@link RefaktorChanger} that is responsible for running an
+ * {@link AggregationAnalyzer} and executing the
+ * {@link ExtractAndMoveMethodExecutor} on all results returned from it.
+ */
+public class ExtractAndMoveMethodAggregationAnalyzerChanger implements RefaktorChanger {
+
+ private AggregationAnalyzer<ExtractAndMoveMethodCandidate> analyzer;
+
+ public ExtractAndMoveMethodAggregationAnalyzerChanger(AggregationAnalyzer<ExtractAndMoveMethodCandidate> analyzer) {
+ this.analyzer = analyzer;
+ }
+
+ @Override
+ public void checkPreconditions() throws RefaktorAnalyzerException {
+ analyzer.analyze();
+ }
+
+ @Override
+ public void execute(IProgressMonitor monitor) throws CoreException {
+ for (ExtractAndMoveMethodCandidate result: analyzer.getResults()) {
+ try {
+ RefaktorDebug.println();
+ RefaktorDebug.println(this, result);
+ ExtractAndMoveMethodExecutor executor = new ExtractAndMoveMethodExecutor(result);
+ executor.execute(new NullProgressMonitor());
+ } catch (RefactoringNotExecutedException e) {
+ RefaktorDebug.log(e);
+ } catch (RefaktorChangerException e) {
+ RefaktorDebug.log(e);
+ }
+ }
+ }
+}
\ No newline at end of file
public class PackageWideExtractAndMoveMethodChanger implements RefaktorChanger {
- private AggregationAnalyzerChanger changer;
+ private ExtractAndMoveMethodAggregationAnalyzerChanger changer;
public PackageWideExtractAndMoveMethodChanger(IPackageFragment packageFragment) {
- changer = new AggregationAnalyzerChanger(new PackageWideExtractAndMoveMethodAnalyzer(packageFragment));
+ changer = new ExtractAndMoveMethodAggregationAnalyzerChanger(new PackageWideExtractAndMoveMethodAnalyzer(packageFragment));
}
@Override
* positive results from the analysis. See {@link ExtractAndMoveMethodCandidate}.
*
* This is done with the help of a {@link ProjectWideExtractAndMoveMethodAnalyzer}
- * and an {@link AggregationAnalyzerChanger}.
+ * and an {@link ExtractAndMoveMethodAggregationAnalyzerChanger}.
*/
public class ProjectWideExtractAndMoveMethodChanger implements RefaktorChanger {
- private AggregationAnalyzerChanger changer;
+ private ExtractAndMoveMethodAggregationAnalyzerChanger changer;
public ProjectWideExtractAndMoveMethodChanger(IProject project) {
if (project == null)
throw new IllegalArgumentException();
- changer = new AggregationAnalyzerChanger(new ProjectWideExtractAndMoveMethodAnalyzer(project));
+ changer = new ExtractAndMoveMethodAggregationAnalyzerChanger(new ProjectWideExtractAndMoveMethodAnalyzer(project));
}
public ProjectWideExtractAndMoveMethodChanger(IJavaProject javaProject) {
if (javaProject == null)
throw new IllegalArgumentException();
- changer = new AggregationAnalyzerChanger(new ProjectWideExtractAndMoveMethodAnalyzer(javaProject));
+ changer = new ExtractAndMoveMethodAggregationAnalyzerChanger(new ProjectWideExtractAndMoveMethodAnalyzer(javaProject));
}
@Override
--- /dev/null
+package no.uio.ifi.refaktor.change.changers;
+
+import no.uio.ifi.refaktor.analyze.analyzers.ProjectWideRefactoringAnalyzer;
+import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
+import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
+import no.uio.ifi.refaktor.change.executors.RefactoringExecutor;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jdt.core.IJavaProject;
+
+/**
+ * A {@link RefaktorChanger} that is responsible for analyzing all of the methods
+ * in a project and execute the {@link RefactoringExecutor} on all of the
+ * positive results from the analysis. See {@link ExtractLocalVariableCandidate}.
+ *
+ * This is done with the help of a {@link ProjectWideExtractAndMoveMethodAnalyzer}
+ * and an {@link ExtractAndMoveMethodAggregationAnalyzerChanger}.
+ */
+public class ProjectWideExtractLocalVariableChanger implements RefaktorChanger {
+
+ private AggregationAnalyzerChanger changer;
+
+ public ProjectWideExtractLocalVariableChanger(IProject project) {
+ if (project == null)
+ throw new IllegalArgumentException();
+ changer = new AggregationAnalyzerChanger(new ProjectWideRefactoringAnalyzer<ExtractLocalVariableCandidate>(project));
+ }
+
+ public ProjectWideExtractLocalVariableChanger(IJavaProject javaProject) {
+ if (javaProject == null)
+ throw new IllegalArgumentException();
+ changer = new AggregationAnalyzerChanger(new ProjectWideRefactoringAnalyzer(javaProject));
+ }
+
+ @Override
+ public void checkPreconditions() throws RefaktorAnalyzerException {
+ changer.checkPreconditions();
+ }
+
+ @Override
+ public void execute(IProgressMonitor monitor) throws CoreException {
+ changer.execute(monitor);
+ }
+
+}
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
import no.uio.ifi.refaktor.change.changers.ExtractLocalVariableWithAssertsChanger;
import no.uio.ifi.refaktor.textselection.CompilationUnitTextSelection;
/**
+ * RefactoringExecutor spesific for Extract Local variable refactoring
*
*
+ * TODO Might be changed
+ *
*
* @author Anna Eilertsen
*
*/
-public class ExtractLocalVariableExecutor implements Executor{
+public class RefactoringExecutor<Candidate extends RefactorCandidate> implements Executor{
/**
* Text selection containing the expression we want to refactor, and only that
private CompilationUnitTextSelection textSelection;
private String newVariableNameName;
- public ExtractLocalVariableExecutor(ExtractLocalVariableCandidate analysisResult) {
+ public RefactoringExecutor(Candidate analysisResult) {
this.textSelection = analysisResult.getTextSelection();
this.newVariableNameName = analysisResult.generateName();
}
--- /dev/null
+package no.uio.ifi.refaktor.factories;
+
+import org.eclipse.jdt.core.IMethod;
+
+import no.uio.ifi.refaktor.analyze.analyzers.ExtractAndMoveMethodAnalyzer;
+import no.uio.ifi.refaktor.analyze.analyzers.ExtractLocalVariableSelectionAnalyzer;
+import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
+import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
+import no.uio.ifi.refaktor.textselection.CompilationUnitTextSelection;
+
+public class RefactoringFactory<Candidate extends RefactorCandidate>{
+
+ public static ExtractLocalVariableCandidate getInstance(Class<? extends RefactorCandidate> class1){
+ return null;
+
+ }
+
+ public static RefactorCandidate getInstance(Class<? extends ExtractLocalVariableCandidate> c, IMethod method/*, ExtractLocalVariableSelectionAnalyzer analyzer*/, CompilationUnitTextSelection textSelection, int numberOfStatementsAnalyzed, int numberOfTextSelectionsAnalyzed){
+ return new ExtractLocalVariableCandidate(method, null, textSelection, numberOfStatementsAnalyzed, numberOfTextSelectionsAnalyzed);
+ }
+
+ public static <Candidate extends ExtractAndMoveMethodCandidate> ExtractAndMoveMethodCandidate RefactoringFactory(Candidate c, IMethod method /*, ExtractAndMoveMethodAnalyzer analyzer*/, CompilationUnitTextSelection textSelection, int numberOfStatementsAnalyzed, int numberOfTextSelectionsAnalyzed){
+ return new ExtractAndMoveMethodCandidate(method, null, textSelection, numberOfStatementsAnalyzed, numberOfTextSelectionsAnalyzed);
+ }
+
+}
import no.uio.ifi.refaktor.analyze.analyzers.CompilationUnitWideExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
-import no.uio.ifi.refaktor.change.changers.AggregationAnalyzerChanger;
+import no.uio.ifi.refaktor.change.changers.ExtractAndMoveMethodAggregationAnalyzerChanger;
import no.uio.ifi.refaktor.change.changers.RefaktorChanger;
public class CompilationUnitWideExtractAndMoveMethodChanger implements RefaktorChanger {
- private final AggregationAnalyzerChanger changer;
+ private final ExtractAndMoveMethodAggregationAnalyzerChanger changer;
public CompilationUnitWideExtractAndMoveMethodChanger(ICompilationUnit compilationUnit) {
- changer = new AggregationAnalyzerChanger(new CompilationUnitWideExtractAndMoveMethodAnalyzer(compilationUnit));
+ changer = new ExtractAndMoveMethodAggregationAnalyzerChanger(new CompilationUnitWideExtractAndMoveMethodAnalyzer(compilationUnit));
}
@Override
package no.uio.ifi.refaktor.handlers;
import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
-import no.uio.ifi.refaktor.analyze.analyzers.TypeWideExtractAndMoveMethodAnalyzer;
+import no.uio.ifi.refaktor.analyze.analyzers.TypeWideRefactorAnalyzer;
import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
import org.eclipse.jdt.core.IType;
protected AggregationAnalyzer<ExtractAndMoveMethodCandidate> createAnalyzer(Object element) {
assert element instanceof IType;
IType type = (IType) element;
- return new TypeWideExtractAndMoveMethodAnalyzer(type);
+ return new TypeWideRefactorAnalyzer(type);
}
}
--- /dev/null
+package no.uio.ifi.refaktor.handlers;
+
+import no.uio.ifi.refaktor.analyze.analyzers.AggregationAnalyzer;
+import no.uio.ifi.refaktor.analyze.analyzers.TypeWideRefactorAnalyzer;
+import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
+
+import org.eclipse.jdt.core.IType;
+
+public class TypeWideSearchBasedExtractLocalVariableAnalysisHandler extends AbstractSearchBasedExtractAndMoveMethodAnalysisHandler {
+
+ @Override
+ protected AggregationAnalyzer<ExtractAndMoveMethodCandidate> createAnalyzer(Object element) {
+ assert element instanceof IType;
+ IType type = (IType) element;
+ return new TypeWideRefactorAnalyzer(type);
+ }
+
+}
import no.uio.ifi.refaktor.analyze.analyzers.ExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.PackageWideExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.SearchBasedExtractAndMoveMethodAnalyzer;
-import no.uio.ifi.refaktor.analyze.analyzers.TypeWideExtractAndMoveMethodAnalyzer;
+import no.uio.ifi.refaktor.analyze.analyzers.TypeWideRefactorAnalyzer;
import no.uio.ifi.refaktor.analyze.candidates.ExtractAndMoveMethodCandidate;
import no.uio.ifi.refaktor.change.executors.ExtractAndMoveMethodExecutor;
import no.uio.ifi.refaktor.change.executors.ExtractMethodPostExecutionResources;
call(* SearchBasedExtractAndMoveMethodAnalyzer.analyze()) && target(analyzer);
pointcut typeAnalyze() :
- call(* TypeWideExtractAndMoveMethodAnalyzer.analyze());
+ call(* TypeWideRefactorAnalyzer.analyze());
pointcut compilationUnitAnalyze() :
call(* CompilationUnitWideExtractAndMoveMethodAnalyzer.analyze());
git://git.uio.no / ifi-stolz-refaktor.git / commitdiff