--- /dev/null
+package aSimpleExample;
+
+
+public class Offset {
+
+
+ public void foo(){
+ X x = new X();
+ x.n();
+ x.n();
+ }
+
+ class X{
+
+ void n(){
+
+ }
+
+ void m(){
+
+ }
+ }
+
+ public void bar(){
+ X x = new X();
+ x.m();
+ x.m();
+ }
+}
\ No newline at end of file
--- /dev/null
+package a_offset;
+
+
+public class Offset {
+
+
+ public void foo(){
+ X x = new X();
+ x.n();
+ x.n();
+ }
+
+ class X{
+
+ void n(){
+
+ }
+
+ void m(){
+
+ }
+ }
+
+ public void bar(){
+ X x = new X();
+ x.m();
+ x.m();
+ }
+}
\ No newline at end of file
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 no.uio.ifi.refaktor.forTests.Refactorer;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
public class ProjectWideExtractLocalVariableChangerTest {
interface Setup {
- RefaktorChanger setup() throws CoreException;
+ Refactorer setup() throws CoreException;
}
// } }
/* 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());}} }
+ { new Setup() { public Refactorer 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());
+// }
+
@Test
- public void testAnalyzeAndChange() throws CoreException {
+ public void testAnalyzeAndChange() throws CoreException{
ExampleCodeManager.INSTANCE.loadExampleCode(); // could be in setup() as well.
- RefaktorChanger changer = setup.setup();
+ Refactorer refactorer = setup.setup();
try {
- changer.checkPreconditions();
- changer.execute(new NullProgressMonitor());
+ refactorer.refactor(new NullProgressMonitor());
} catch (RefaktorAnalyzerException e) {
fail("Preconditions failed to validate.");
} catch (CoreException e) {
}
ExampleCodeManager.INSTANCE.cleanBuild();
- assertThat("Project has errors after change.", !ExampleCodeManager.INSTANCE.projectHasErrors());
+ assertThat("Project has errors after change.", !ExampleCodeManager.INSTANCE.projectHasErrors());
}
}
* 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> {
+public class CompilationUnitWideRefactorer<Candidate extends ExtractLocalVariableCandidate> implements AggregationAnalyzer<Candidate> {
private final ICompilationUnit compilationUnit;
private final List<Candidate> results;
- public CompilationUnitWideRefactorAnalyzer(ICompilationUnit compilationUnit) {
+ public CompilationUnitWideRefactorer(ICompilationUnit compilationUnit) {
this.compilationUnit = compilationUnit;
results = new LinkedList<Candidate>();
}
}
private void analyzeMethodsInType(IType type) throws JavaModelException {
- TypeWideRefactorAnalyzer<Candidate> analyzer = new TypeWideRefactorAnalyzer<Candidate>(type);
- analyzer.analyze();
- results.addAll(analyzer.getResults());
+ TypeWideRefactorer<Candidate> refactorer = new TypeWideRefactorer<Candidate>(type);
+ refactorer.analyze();
+ results.addAll(refactorer.getResults());
}
}
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.IPackageFragment;
import org.eclipse.jdt.core.JavaModelException;
-abstract public class PackageFragmentParentRefactoringAnalyzer<Candidate extends RefactorCandidate> implements AggregationAnalyzer<Candidate> {
+abstract public class PackageFragmentParentRefactoring<Candidate extends ExtractLocalVariableCandidate> implements AggregationAnalyzer<Candidate> {
private final List<Candidate> results;
- public PackageFragmentParentRefactoringAnalyzer() {
+ public PackageFragmentParentRefactoring() {
results = new LinkedList<Candidate>();
}
@Override
public void analyze() throws RefaktorAnalyzerException {
try {
- analyzeMethodsInPackages();
+ refactorMethodsInPackages();
} catch (JavaModelException e) {
RefaktorDebug.log(e);
}
protected abstract List<IPackageFragment> getPackages() throws JavaModelException;
- private void analyzeMethodsInPackages() throws JavaModelException {
+ private void refactorMethodsInPackages() throws JavaModelException {
for (IPackageFragment packageFragment: getPackages()) {
- analyzeMethodsInPackage(packageFragment);
+ refactorMethodsInPackage(packageFragment);
}
}
- private void analyzeMethodsInPackage(IPackageFragment packageFragment) throws JavaModelException {
+ private void refactorMethodsInPackage(IPackageFragment packageFragment) throws JavaModelException {
//TODO make generic
- PackageWideRefactorAnalyzer<Candidate> analyzer =
- new PackageWideRefactorAnalyzer<Candidate>(packageFragment);
- analyzer.analyze();
- results.addAll(analyzer.getResults());
+ PackageWideRefactorer<Candidate> refactorer =
+ new PackageWideRefactorer<Candidate>(packageFragment);
+ refactorer.analyze();
+// results.addAll(refactorer.getResults());
}
}
\ No newline at end of file
* Responsible for analyzing all methods in a package for
* candidates to the Extract and Move Method refactoring.
*/
-public class PackageWideRefactorAnalyzer<Candidate extends RefactorCandidate> implements AggregationAnalyzer<Candidate> {
+public class PackageWideRefactorer<Candidate extends ExtractLocalVariableCandidate> implements AggregationAnalyzer<Candidate> {
private final IPackageFragment packageFragment;
private final List<Candidate> results;
- public PackageWideRefactorAnalyzer(IPackageFragment packageFragment) {
+ public PackageWideRefactorer(IPackageFragment packageFragment) {
this.packageFragment = packageFragment;
results = new LinkedList<Candidate>();
}
}
private void analyzeMethodsInCompilationUnit(ICompilationUnit compilationUnit) {
- CompilationUnitWideRefactorAnalyzer<Candidate> analyzer =
- new CompilationUnitWideRefactorAnalyzer<Candidate>(compilationUnit);
- analyzer.analyze();
- results.addAll(analyzer.getResults());
+ CompilationUnitWideRefactorer<Candidate> refactorer =
+ new CompilationUnitWideRefactorer<Candidate>(compilationUnit);
+ refactorer.analyze();
+// results.addAll(refactorer.getResults());
}
}
import java.util.Arrays;
import java.util.List;
+import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
import no.uio.ifi.refaktor.analyze.candidates.RefactorCandidate;
import no.uio.ifi.refaktor.utils.RefaktorHandleUtils;
*
* @author Anna Eilertsen
*/
-public class ProjectWideRefactoringAnalyzer<Candidate extends RefactorCandidate> extends PackageFragmentParentRefactoringAnalyzer<Candidate> {
+public class ProjectWideRefactoring<Candidate extends ExtractLocalVariableCandidate> extends PackageFragmentParentRefactoring<Candidate> {
private final IJavaProject javaProject;
- public ProjectWideRefactoringAnalyzer(IProject project) {
+ public ProjectWideRefactoring(IProject project) {
this(RefaktorHandleUtils.createJavaProjectFrom(project));
}
- public ProjectWideRefactoringAnalyzer(IJavaProject javaProject) {
+ public ProjectWideRefactoring(IJavaProject javaProject) {
this.javaProject = javaProject;
}
* @author Anna Eilertsen
*
*/
-public class SearchBasedRefactorAnalyzer<Candidate extends RefactorCandidate> implements Analyzer{
+public class SearchBasedRefactorAnalyzer<Candidate extends ExtractLocalVariableCandidate> implements Analyzer{
private IMethod method;
private Comparator<Candidate> candidateComparator;
public void analyze() {
try {
generateTextSelections();
-
- /*
+ /*
* TODO Seriously, I have no idea how to solve this
*/
// ExtractLocalVariableCandidate b = new ExtractLocalVariableCandidate(method, null, null, 0, 0);
private void findPotentialExtractLocalVariableCandidates() {
for (CompilationUnitTextSelection textSelection: textSelections) {
+ String text = textSelection.getText();
ExtractLocalVariableSelectionAnalyzer analyzer = new ExtractLocalVariableSelectionAnalyzer(textSelection);
analyzer.analyze();
+++ /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.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;
-
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-
-/**
- * Responsible for analyzing all methods in a type for
- * candidates to the Extract and Move Method refactoring.
- */
-public class TypeWideRefactorAnalyzer<Candidate extends RefactorCandidate> implements AggregationAnalyzer<Candidate> {
-
- private final IType type;
- private final List<Candidate> candidates;
-
- public TypeWideRefactorAnalyzer(IType type) {
- this.type = type;
- candidates = new LinkedList<Candidate>();
- }
-
- @Override
- public List<Candidate> getResults() {
- return candidates;
- }
-
- @Override
- public void analyze() throws RefaktorAnalyzerException {
- try {
- analyzeMethodsInType();
- } catch (JavaModelException e) {
- RefaktorDebug.log(e);
- }
- }
-
- private void analyzeMethodsInType() throws JavaModelException {
- for (IMethod method: type.getMethods()) {
- analyzeMethod(method);
- }
- }
-
- private void analyzeMethod(IMethod method) {
- try {
- SearchBasedRefactorAnalyzer<Candidate> analyzer =
- new SearchBasedRefactorAnalyzer<Candidate>(method, new FavorNoUnfixesComparator<Candidate>());
- analyzer.analyze();
- candidates.add(analyzer.getCandidate());
- } catch (NoTargetFoundException e) {
- // Ignoring
- } catch (AssertionError err) {
- RefaktorDebug.log(err);
- } catch (Exception e) {
- RefaktorDebug.log(e);
- }
- }
-}
--- /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.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.change.SearchBasedExtractLocalVariableWithAssertsChanger;
+import no.uio.ifi.refaktor.change.changers.ExtractLocalVariableWithAssertsChanger;
+import no.uio.ifi.refaktor.debugging.RefaktorDebug;
+import no.uio.ifi.refaktor.handlers.SearchBasedExtractLocalVariableWithAssertsHandler;
+
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.internal.corext.refactoring.code.ExtractTempRefactoring;
+
+/**
+ * Responsible for analyzing all methods in a type for
+ * candidates to the Extract Local refactoring.
+ *
+ * @author Anna Eilertsen
+ */
+public class TypeWideRefactorer<Candidate extends ExtractLocalVariableCandidate> implements AggregationAnalyzer<Candidate> {
+
+ private final IType type;
+ private final List<Candidate> candidates;
+
+ public TypeWideRefactorer(IType type) {
+ this.type = type;
+ candidates = new LinkedList<Candidate>();
+ }
+
+ @Override
+ public List<Candidate> getResults() {
+ return candidates;
+ }
+
+ @Override
+ public void analyze() throws RefaktorAnalyzerException {
+ try {
+ refactorMethodsInType();
+ } catch (JavaModelException e) {
+ RefaktorDebug.log(e);
+ }
+ }
+
+ private void refactorMethodsInType() throws JavaModelException {
+ for (IMethod method: type.getMethods()) {
+ refactorMethod(method);
+ }
+ }
+
+ private void refactorMethod(IMethod method) {
+ try {
+
+ SearchBasedExtractLocalVariableWithAssertsChanger changer = new SearchBasedExtractLocalVariableWithAssertsChanger(method);
+
+ changer.checkPreconditions();
+ changer.execute(new NullProgressMonitor());
+//
+// SearchBasedRefactorAnalyzer<Candidate> analyzer =
+// new SearchBasedRefactorAnalyzer<Candidate>(method, new FavorNoUnfixesComparator<Candidate>());
+// analyzer.analyze();
+// if(analyzer.getCandidate() != null){
+// //TODO rename alle the way down: analyze AND execute
+// Candidate candidate = analyzer.getCandidate();
+// String text = candidate.getTextSelection().getText();
+// new ExtractLocalVariableWithAssertsChanger(candidate).execute(new NullProgressMonitor());;
+// candidates.add(candidate);
+// }
+ } catch (NoTargetFoundException e) {
+ // Ignoring
+ } catch (AssertionError err) {
+ RefaktorDebug.log(err);
+ } catch (Exception e) {
+ RefaktorDebug.log(e);
+ }
+ }
+}
import no.uio.ifi.refaktor.change.executors.ExtractAndMoveMethodExecutor;
import no.uio.ifi.refaktor.change.executors.RefactoringExecutor;
import no.uio.ifi.refaktor.debugging.RefaktorDebug;
+import no.uio.ifi.refaktor.forTests.Refactorer;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
*
* @author Anna Eilertsen
*/
-public class AggregationAnalyzerChanger<Candidate extends RefactorCandidate> implements RefaktorChanger {
+public class AggregationAnalyzerChanger<Candidate extends RefactorCandidate> implements Refactorer{
private AggregationAnalyzer<Candidate> analyzer;
this.analyzer = analyzer;
}
- @Override
- public void checkPreconditions() throws RefaktorAnalyzerException {
- analyzer.analyze();
- }
@Override
- public void execute(IProgressMonitor monitor) throws CoreException {
- for (Candidate result: analyzer.getResults()) {
- try {
- RefaktorDebug.println();
- RefaktorDebug.println(this, result);
- RefactoringExecutor<Candidate> executor = new RefactoringExecutor<Candidate>(result);
- executor.execute(new NullProgressMonitor());
- } catch (RefactoringNotExecutedException e) {
- RefaktorDebug.log(e);
- } catch (RefaktorChangerException e) {
- RefaktorDebug.log(e);
- }
- }
+ public void refactor(IProgressMonitor monitor) throws CoreException, RefaktorAnalyzerException {
+ analyzer.analyze();
+// for (Candidate result: analyzer.getResults()) {
+//
+// //Debug:
+//// for (Candidate r: analyzer.getResults())
+// int index = 4;
+// Candidate r = analyzer.getResults().get(index);
+// System.out.println(r.toString() + ": " + r.getTextSelection().getText());
+// System.out.println("Currently refactoring " + result);
+// try {
+// RefaktorDebug.println();
+// RefaktorDebug.println(this, result);
+// RefactoringExecutor<Candidate> executor = new RefactoringExecutor<Candidate>(result);
+// executor.execute(new NullProgressMonitor());
+//
+// } catch (RefactoringNotExecutedException e) {
+// RefaktorDebug.log(e);
+// } catch (RefaktorChangerException e) {
+// RefaktorDebug.log(e);
+// }
+// r = analyzer.getResults().get(index);
+// System.out.println(r.toString() + ": " + r.getTextSelection().getText());
+// System.out.println();
+// }
}
}
\ No newline at end of file
@Override
public void execute(IProgressMonitor monitor) throws CoreException {
for (ExtractAndMoveMethodCandidate result: analyzer.getResults()) {
+// //Debug:
+// for (ExtractAndMoveMethodCandidate r: analyzer.getResults())
+// System.out.println(r.toString() + ": " + r.getTextSelection().getText());
+//
+
try {
RefaktorDebug.println();
RefaktorDebug.println(this, result);
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.ltk.core.refactoring.Change;
+
+import no.uio.ifi.refaktor.analyze.candidates.ExtractLocalVariableCandidate;
import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
import no.uio.ifi.refaktor.refactorings.ExtractTempWithAssertsRefactoring;
import no.uio.ifi.refaktor.textselection.CompilationUnitTextSelection;
refactorer = new ExtractTempWithAssertsRefactoring(textSelection.getCompilationUnit(), textSelection.getOffset(), textSelection.getLength(), textSelection.getText());
refactorer.setTempName(newVariableName);
}
+
+ public ExtractLocalVariableWithAssertsChanger(ExtractLocalVariableCandidate candidate) {
+ cstextsel = candidate.getTextSelection();
+ refactorer = new ExtractTempWithAssertsRefactoring(cstextsel.getCompilationUnit(), cstextsel.getOffset(), cstextsel.getLength(), cstextsel.getText());
+ refactorer.setTempName(generateName());
+ }
+
@Override
public void checkPreconditions() throws RefaktorAnalyzerException {
try {
package no.uio.ifi.refaktor.change.changers;
-import no.uio.ifi.refaktor.analyze.analyzers.ProjectWideRefactoringAnalyzer;
+import no.uio.ifi.refaktor.analyze.analyzers.ProjectWideRefactoring;
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 no.uio.ifi.refaktor.forTests.Refactorer;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
* 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}.
+ * @author Anna Eilertsen
*/
-public class ProjectWideExtractLocalVariableChanger implements RefaktorChanger {
+public class ProjectWideExtractLocalVariableChanger implements Refactorer {
private AggregationAnalyzerChanger<ExtractLocalVariableCandidate> changer;
public ProjectWideExtractLocalVariableChanger(IProject project) {
if (project == null)
throw new IllegalArgumentException();
- changer = new AggregationAnalyzerChanger<ExtractLocalVariableCandidate>(new ProjectWideRefactoringAnalyzer<ExtractLocalVariableCandidate>(project));
+ changer = new AggregationAnalyzerChanger<ExtractLocalVariableCandidate>(new ProjectWideRefactoring<ExtractLocalVariableCandidate>(project));
}
public ProjectWideExtractLocalVariableChanger(IJavaProject javaProject) {
if (javaProject == null)
throw new IllegalArgumentException();
- changer = new AggregationAnalyzerChanger<ExtractLocalVariableCandidate>(new ProjectWideRefactoringAnalyzer<ExtractLocalVariableCandidate>(javaProject));
+ changer = new AggregationAnalyzerChanger<ExtractLocalVariableCandidate>(new ProjectWideRefactoring<ExtractLocalVariableCandidate>(javaProject));
}
@Override
- public void checkPreconditions() throws RefaktorAnalyzerException {
- changer.checkPreconditions();
- }
-
- @Override
- public void execute(IProgressMonitor monitor) throws CoreException {
- changer.execute(monitor);
+ public void refactor(IProgressMonitor monitor) throws CoreException, RefaktorAnalyzerException {
+ changer.refactor(monitor);
}
}
--- /dev/null
+package no.uio.ifi.refaktor.forTests;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+
+import no.uio.ifi.refaktor.analyze.exceptions.RefaktorAnalyzerException;
+
+/**
+ * This interface is an alterntive to RefaktorChanger
+ *
+ * @author Anna Eilertsen
+ *
+ */
+public interface Refactorer {
+
+
+ /**
+ * Analyzes and performs the refactoring
+ *
+ * @param monitor The monitor to use in when dealing with workspace changes.
+ * @throws CoreException if anything goes wrong at the core level
+ * {@link RefaktorAnalyzerException} if a analyzis goes wrong
+ */
+ public void refactor(IProgressMonitor monitor) throws CoreException, RefaktorAnalyzerException;
+}
git://git.uio.no / ifi-stolz-refaktor.git / commitdiff