Moving comparators to no.uio.ifi.refaktor.analyze.comparators

[ifi-stolz-refaktor.git] / software / no.uio.ifi.refaktor / src / no / uio / ifi / refaktor / analyze / SearchBasedExtractAndMoveMethodAnalyzer.java

package no.uio.ifi.refaktor.analyze;

import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Set;

import no.uio.ifi.refaktor.analyze.comparators.ExtractAndMoveMethodAnalysisResultComparator;
import no.uio.ifi.refaktor.analyze.comparators.IgnorantAnalysisResultComparator;
import no.uio.ifi.refaktor.utils.CompilationUnitTextSelection;
import no.uio.ifi.refaktor.utils.RefaktorDebug;

import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.Statement;

/**
 * A class for searching through a method body to find the best
 * candidate for the Extract and Move Method refactoring.
 */
public class SearchBasedExtractAndMoveMethodAnalyzer implements Analyzer {

	private final IMethod method;
	private final ExtractAndMoveMethodAnalysisResultComparator analysisResultComparator;
	private final AnalysisStatistics statistics;
	private Set<CompilationUnitTextSelection> textSelections;
	private LinkedList<ExtractAndMoveMethodAnalysisResult> possibleResults;
	private ExtractAndMoveMethodAnalysisResult chosenResult;
	private StatementsCreator statementsCreator;

	public SearchBasedExtractAndMoveMethodAnalyzer(IMethod method) {
		this(method, new IgnorantAnalysisResultComparator());
	}

	public SearchBasedExtractAndMoveMethodAnalyzer(IMethod method, 
			ExtractAndMoveMethodAnalysisResultComparator analysisResultComparator) {
		this(method, analysisResultComparator, new AnalysisStatistics());
	}

	/**
	 * @param method The handler for the method to analyze.
	 * @param analysisResultComparator A result comparator to compare two analysis results when deciding
	 * 		which of them that is the best candidate for the refactoring.
	 * @param statistics 
	 */
	public SearchBasedExtractAndMoveMethodAnalyzer(IMethod method, 
			ExtractAndMoveMethodAnalysisResultComparator analysisResultComparator, AnalysisStatistics statistics) {
		this.method = method;
		this.analysisResultComparator = analysisResultComparator;
		this.statistics = statistics;
		textSelections = new HashSet<CompilationUnitTextSelection>();
		possibleResults = new LinkedList<ExtractAndMoveMethodAnalysisResult>();
		statementsCreator = new StatementsCreator(method);
	}

	public ExtractAndMoveMethodAnalysisResult getResult() {
		return chosenResult;
	}

	@Override
	public void analyze() {
		statistics.incrementMethodCount();

		printDebugInfo();

		// TODO: make the Extract and Move Method Refactoring work with static methods
		abortIfStaticMethod();

		generateTextSelections();
		generatePossibleResults();

		if (possibleResults.isEmpty())
			throw new NoTargetFoundException();

		chooseResult();
	}

	private void printDebugInfo() {
		try {
			RefaktorDebug.println("#" + statistics.getMethodCount() + " (" + statistics.timeSinceStart() + "): " + method.getDeclaringType().getElementName() + "." + method.getElementName() + " (" + "offset: "
					+ method.getSourceRange().getOffset() + ", length: " + method.getSourceRange().getLength() + ")");
		} catch (JavaModelException e) {
			RefaktorDebug.println("No info about " + method.getElementName());
		}
	}

	private void abortIfStaticMethod() {
		try {
			if (Flags.isStatic(method.getFlags()))
				throw new NoTargetFoundException(method.getElementName() + " is static!");
		} catch (JavaModelException e) {
			RefaktorDebug.log(e);
			throw new GenericAnalyzerException(e);
		}
	}

	private void generateTextSelections() {
		for (Statement statement: statementsCreator.getStatements())
			generateSelectionsFrom(statement);
	}

	private void generateSelectionsFrom(Statement statement) {
		Set<CompilationUnitTextSelection> newSelections = new HashSet<CompilationUnitTextSelection>();
		CompilationUnitTextSelection textSelectionFromStatement = createTextSelectionFromStatement(statement);
		newSelections.add(textSelectionFromStatement);

		for (CompilationUnitTextSelection textSelection: textSelections)
			newSelections.add(addTextSelections(textSelection, textSelectionFromStatement));

		textSelections.addAll(newSelections);
	}

	private CompilationUnitTextSelection createTextSelectionFromStatement(Statement statement) {
		return new CompilationUnitTextSelection(method.getCompilationUnit(), statement.getStartPosition(), statement.getLength());
	}

	private CompilationUnitTextSelection addTextSelections(
			CompilationUnitTextSelection textSelectionOne, CompilationUnitTextSelection textSelectionTwo) {
		int offset = Math.min(textSelectionOne.getOffset(), textSelectionTwo.getOffset());
		int length = Math.max(textSelectionOne.getEnd(), textSelectionTwo.getEnd()) - offset;
		return new CompilationUnitTextSelection(textSelectionOne.getCompilationUnit(), offset, length);
	}

	private void generatePossibleResults() {
		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()));
		}
	}

	private void chooseResult() {
		sortPossibleResults();
		chosenResult = possibleResults.getLast();
	}

	private void sortPossibleResults() {
		Collections.sort(possibleResults, analysisResultComparator);
	}
}