bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/correction/CompoundQuickAssistProcessor.java

/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.correction;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.quickassist.IQuickAssistInvocationContext;
import org.eclipse.jface.text.quickassist.IQuickAssistProcessor;
import org.eclipse.jface.text.source.Annotation;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredPartitioning;
import org.eclipse.wst.sse.ui.internal.ExtendedConfigurationBuilder;
import org.eclipse.wst.sse.ui.internal.Logger;

/**
 * A quick assist processor that will allow for more than one quick assist
 * processor. It includes quick assist processors contributed via the
 * quickAssistProcessor extended configuration extension point. It also
 * includes quick assist processors contributed via validators.
 */
public class CompoundQuickAssistProcessor implements IQuickAssistProcessor {
	private final String QUICK_ASSIST_PROCESSOR_EXTENDED_ID = IQuickAssistProcessor.class.getName();
	private Map fProcessors;
	private IQuickAssistProcessor fQuickFixProcessor;
	/**
	 * list of partition types where extended processors have been installed
	 */
	private List fInstalledExtendedContentTypes;

	private Set getQuickAssistProcessors(String partitionType) {
		if (fInstalledExtendedContentTypes == null || !fInstalledExtendedContentTypes.contains(partitionType)) {
			// get extended quick assist processors that have not already
			// been set
			List processors = ExtendedConfigurationBuilder.getInstance().getConfigurations(QUICK_ASSIST_PROCESSOR_EXTENDED_ID, partitionType);
			if (processors != null && !processors.isEmpty()) {
				Iterator iter = processors.iterator();
				while (iter.hasNext()) {
					IQuickAssistProcessor processor = (IQuickAssistProcessor) iter.next();
					setQuickAssistProcessor(partitionType, processor);
				}
			}
			// add partition type to list of extended partition types
			// installed (regardless of whether or not any extended content
			// assist processors were installed because dont want to look it
			// up every time)
			if (fInstalledExtendedContentTypes == null)
				fInstalledExtendedContentTypes = new ArrayList();
			fInstalledExtendedContentTypes.add(partitionType);
		}

		Set processors = null;
		if (fProcessors != null)
			processors = (Set) fProcessors.get(partitionType);

		return processors;
	}

	/**
	 * Gets all the quick assist processors relevant to the partion which is
	 * calcuated from the given document and offset.
	 * 
	 * @param invocationContext
	 * @return Set of quick assist processors or null if none exist
	 */
	private Set getQuickAssistProcessors(IQuickAssistInvocationContext invocationContext) {
		Set processsors = null;

		ISourceViewer sourceViewer = invocationContext.getSourceViewer();
		if (sourceViewer != null) {
			IDocument document = sourceViewer.getDocument();
			try {
				String partitionType;
				if (document != null)
					partitionType = TextUtilities.getContentType(document, IStructuredPartitioning.DEFAULT_STRUCTURED_PARTITIONING, invocationContext.getOffset(), true);
				else
					partitionType = IDocument.DEFAULT_CONTENT_TYPE;

				processsors = getQuickAssistProcessors(partitionType);
			}
			catch (BadLocationException x) {
				Logger.log(Logger.WARNING_DEBUG, x.getMessage(), x);
			}
		}

		return processsors;
	}

	/**
	 * Gets the quick assist processor for validator contributed quick fixes
	 * 
	 * @return IQuickAssistProcessor
	 */
	private IQuickAssistProcessor getQuickFixProcessor() {
		if (fQuickFixProcessor == null)
			fQuickFixProcessor = new SourceValidationQuickAssistProcessor();

		return fQuickFixProcessor;
	}

	/**
	 * Associates a quick assist processor to a partition type and adds it to
	 * the list of processors in this compound processor.
	 * 
	 * @param partitionType
	 * @param processor
	 */
	private void setQuickAssistProcessor(String partitionType, IQuickAssistProcessor processor) {
		if (fProcessors == null)
			fProcessors = new HashMap();

		Set processors = (Set) fProcessors.get(partitionType);

		if (processor == null && processors != null) {
			// removing quick assist processor for this partition type
			processors.clear();
			// check if it's the only
			fProcessors.remove(partitionType);
		}
		else {
			if (processors == null) {
				processors = new LinkedHashSet();
			}
			processors.add(processor);
			fProcessors.put(partitionType, processors);
		}
	}

	public boolean canAssist(IQuickAssistInvocationContext invocationContext) {
		Set processors = getQuickAssistProcessors(invocationContext);
		if (processors != null) {
			// iterate through list of processors until one processor says
			// canAssist
			for (Iterator it = processors.iterator(); it.hasNext();) {
				IQuickAssistProcessor p = (IQuickAssistProcessor) it.next();
				if (p.canAssist(invocationContext))
					return true;
			}
		}
		return false;
	}

	public boolean canFix(Annotation annotation) {
		// only quick fix processor contributes fixes so just check it
		IQuickAssistProcessor processor = getQuickFixProcessor();
		return processor.canFix(annotation);
	}

	public ICompletionProposal[] computeQuickAssistProposals(IQuickAssistInvocationContext invocationContext) {
		List proposalsList = new ArrayList();

		// first get list of fixes
		IQuickAssistProcessor processor = getQuickFixProcessor();
		ICompletionProposal[] proposals = processor.computeQuickAssistProposals(invocationContext);
		if (proposals != null && proposals.length > 0) {
			proposalsList.addAll(Arrays.asList(proposals));
		}

		// no fixes, so try adding assists
		if (proposalsList.isEmpty()) {
			Set processors = getQuickAssistProcessors(invocationContext);
			if (processors != null) {
				// iterate through list of processors until one processor says
				// canAssist
				for (Iterator it = processors.iterator(); it.hasNext();) {
					IQuickAssistProcessor assistProcessor = (IQuickAssistProcessor) it.next();
					ICompletionProposal[] assistProposals = assistProcessor.computeQuickAssistProposals(invocationContext);
					if (assistProposals != null && assistProposals.length > 0) {
						proposalsList.addAll(Arrays.asList(assistProposals));
					}
				}
			}
		}

		/*
		 * Java editor currently returns a no modification completion proposal
		 * but it seems better to just return null so user does not get
		 * annoying proposal popup
		 */
		if (proposalsList.isEmpty()) {
			// proposalsList.add(new NoModificationCompletionProposal());
			return null;
		}

		return (ICompletionProposal[]) proposalsList.toArray(new ICompletionProposal[proposalsList.size()]);
	}

	public String getErrorMessage() {
		// never have error messages
		return null;
	}

}