Adding some JavaDoc and cleaning up a bit.

[ifi-stolz-refaktor.git] / software / no.uio.ifi.refaktor / src / no / uio / ifi / refaktor / extractors / CommonPrefixExtractor.java

package no.uio.ifi.refaktor.extractors;

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

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

import org.eclipse.jdt.core.ICompilationUnit;
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.Expression;
import org.eclipse.jdt.core.dom.ExpressionStatement;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.NodeFinder;
import org.eclipse.jdt.core.dom.Statement;

public abstract class CommonPrefixExtractor extends PropertyExtractor {

	private class SelectionAttributesCollector extends ASTVisitor {
	
		private SmartTextSelection selection;
		private LinkedList<ASTNode> selectedStatements;
		private NodeFinder nodeFinder;
	
		public SelectionAttributesCollector(SmartTextSelection selection, ICompilationUnit icu) {
			this.selection = selection;
			this.selectedStatements = new LinkedList<ASTNode>();
			if (icu == null)
				nodeFinder = selection.getNodeFinder();
			else
				nodeFinder = selection.getNodeFinder(icu);
			findSelectedStatements(getCoveringNode());
		}
	
		ASTNode getCoveringNode() {
			return nodeFinder.getCoveringNode();
		}
		
		private ASTNode getCoveredNode() {
			return nodeFinder.getCoveredNode();
		}
		
		public boolean isSingleNodeSelection() {
			return getCoveringNode() == getCoveredNode();
		}
	
		public ASTNode getSelectedNode() {
			if (!isSingleNodeSelection())
				return null;
			return getCoveredNode();
		}
	
		public void findSelectedStatements(ASTNode node) {
			node.accept(this);
			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;
				}});
		}
	
		@Override
		public boolean preVisit2(ASTNode node) {
			if (node instanceof Statement && nodeInSelection(node, selection)) {
				selectedStatements.add(node);
				// Only visit top-level statements
				return false;
			}
	
			if (node instanceof MethodDeclaration || node instanceof Block )
				return true;
	
			return false;
		}
	
		public boolean selectedNodeHasBlockStructure() {
			return isSingleNodeSelection() && 
					(getSelectedNode() instanceof MethodDeclaration || getSelectedNode() instanceof Block);
		}
	
		public boolean noStatementsSelected() {
			return selectedStatements.isEmpty();
		}
		
		boolean selectionMatchesStatementsStartAndEnd() {
			return selectedStatements.getFirst().getStartPosition() == selection.getOffset() 
					&& nodeEnd(selectedStatements.getLast()) == selection.getEnd();
		}
		
		private int nodeEnd(ASTNode astNode) {
			return astNode.getStartPosition() + astNode.getLength();
		}
	}

	private SelectionAttributesCollector selectionAttributesCollector;

	public CommonPrefixExtractor(SmartTextSelection selection) {
		this(selection, null);
	}

	public CommonPrefixExtractor(SmartTextSelection selection, ICompilationUnit icu) {
		super(selection, icu);
		selectionAttributesCollector = new SelectionAttributesCollector(selection, icu);
	}

	/**
	 * @return null, if no prefix is generated from statement.
	 * @Nullable
	 */
	private Prefix getPrefix(ExpressionStatement statement) {
		Expression expression = statement.getExpression();
		// TODO: support more expression types
		if (expression instanceof MethodInvocation)
			return new Prefix(((MethodInvocation) expression).getExpression(), getDocument());
		else
			return null;
	}

	@Override
	public boolean selectionIsValid() {
		if (!super.selectionIsValid())
			return false;
	
		if (selectionAttributesCollector.noStatementsSelected())
			return false;
		
		if (selectionAttributesCollector.selectedNodeHasBlockStructure())
			return true;
		
		return selectionAttributesCollector.selectionMatchesStatementsStartAndEnd();
	}

	@Override
	protected ASTNode getStartNode() {
		return selectionAttributesCollector.getCoveringNode();
	}

	@Override
	public boolean visit(ExpressionStatement node) {
		if (!nodeInSelection(node))
			return false;
	
		final Prefix p = getPrefix(node);
		// No prefix generated?
		if (p != null)
			registerPrefix(p);
		
		return true;
	}

	protected abstract void registerPrefix(Prefix prefix);
}