ExtractAndMoveMethodAnalysisResult: renaming to ExtractAndMoveMethodCandidate

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

package no.uio.ifi.refaktor.analyze.collectors;

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;

import no.uio.ifi.refaktor.utils.CompilationUnitTextSelection;

import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.Statement;

public class SelectionValidator extends ASTVisitor {

	private final CompilationUnitTextSelection selection;
	private final LinkedList<ASTNode> selectedStatements;

	public SelectionValidator(CompilationUnitTextSelection selection) {
		super();
		this.selection = selection;
		this.selectedStatements = new LinkedList<ASTNode>();
		findSelectedStatements();
	}

	private void findSelectedStatements() {
		getCoveringNode().accept(this);
	}

	private ASTNode getCoveringNode() {
		return selection.getCoveringNode();
	}
	
	private ASTNode getCoveredNode() {
		return selection.getCoveredNode();
	}
	
	@Override
	public boolean preVisit2(ASTNode node) {
		if (node instanceof Statement && selection.surroundsNode(node)) {
			selectedStatements.add(node);
			// Only visit top-level statements
			return false;
		}

		if (node instanceof MethodDeclaration || node instanceof Block )
			return true;

		return false;
	}

	public static void checkIfSelectionIsValid(CompilationUnitTextSelection selection) {
		if (!selectionIsValid(selection))
			throw new SelectionInvalidException();
	}

	private static boolean selectionIsValid(CompilationUnitTextSelection selection) {
		return new SelectionValidator(selection).selectionIsValid();
	}
	
	private boolean selectionIsValid() {
		if (noStatementsSelected())
			return false;
		
		if (selectedNodeHasBlockStructure())
			return true;
		
		return selectionMatchesStatementsStartAndEnd();
	}

	private boolean noStatementsSelected() {
		return selectedStatements.isEmpty();
	}
	
	private boolean selectedNodeHasBlockStructure() {
		return isSingleNodeSelection() && 
				(getSelectedNode() instanceof MethodDeclaration || getSelectedNode() instanceof Block);
	}

	private boolean selectionMatchesStatementsStartAndEnd() {
		sortSelectedStatements();
		return selectedStatements.getFirst().getStartPosition() == selection.getOffset() 
				&& nodeEnd(selectedStatements.getLast()) == selection.getEnd();
	}

	private void sortSelectedStatements() {
		Collections.sort(selectedStatements, new Comparator<ASTNode>(){
			@Override
			public int compare(ASTNode node1, ASTNode node2) {
				if (node1.equals(node2))
					return 0;
				else if (node1.getStartPosition() < node2.getStartPosition())
					return -1;
				else if (node1.getStartPosition() > node2.getStartPosition())
					return 1;
				else
					return 0;
			}});
	}
	
	private boolean isSingleNodeSelection() {
		return getCoveringNode() == getCoveredNode();
	}

	private ASTNode getSelectedNode() {
		if (!isSingleNodeSelection())
			return null;
		return getCoveredNode();
	}

	private int nodeEnd(ASTNode astNode) {
		return astNode.getStartPosition() + astNode.getLength();
	}
}