IntelligentCompletionProposalComputer.java

/**
 * Copyright (c) 2010, 2012 Darmstadt University of Technology.
 * 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:
 *    Marcel Bruch - initial API and implementation.
 */
package org.eclipse.recommenders.completion.rcp.processable;

import static org.eclipse.recommenders.completion.rcp.CompletionContextKey.ACTIVE_PROCESSORS;
import static org.eclipse.recommenders.completion.rcp.processable.ProcessableProposalFactory.create;
import static org.eclipse.recommenders.completion.rcp.processable.ProposalTag.*;
import static org.eclipse.recommenders.internal.completion.rcp.Constants.*;
import static org.eclipse.recommenders.internal.completion.rcp.l10n.LogMessages.ERROR_SESSION_PROCESSOR_FAILED;
import static org.eclipse.recommenders.utils.Checks.cast;
import static org.eclipse.recommenders.utils.Logs.log;

import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.inject.Inject;
import javax.inject.Provider;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.CompletionProposal;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;
import org.eclipse.jdt.internal.ui.text.java.CompletionProposalCategory;
import org.eclipse.jdt.internal.ui.text.java.CompletionProposalComputerRegistry;
import org.eclipse.jdt.internal.ui.text.java.JavaAllCompletionProposalComputer;
import org.eclipse.jdt.internal.ui.text.java.JavaMethodCompletionProposal;
import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jdt.ui.text.java.ContentAssistInvocationContext;
import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;
import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.contentassist.ContentAssistEvent;
import org.eclipse.jface.text.contentassist.ICompletionListener;
import org.eclipse.jface.text.contentassist.ICompletionListenerExtension2;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.source.ContentAssistantFacade;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.recommenders.completion.rcp.CompletionContextKey;
import org.eclipse.recommenders.completion.rcp.DisableContentAssistCategoryJob;
import org.eclipse.recommenders.completion.rcp.ICompletionContextFunction;
import org.eclipse.recommenders.completion.rcp.IRecommendersCompletionContext;
import org.eclipse.recommenders.completion.rcp.RecommendersCompletionContext;
import org.eclipse.recommenders.internal.completion.rcp.CompletionRcpPreferences;
import org.eclipse.recommenders.internal.completion.rcp.EmptyCompletionProposal;
import org.eclipse.recommenders.internal.completion.rcp.EnabledCompletionProposal;
import org.eclipse.recommenders.rcp.IAstProvider;
import org.eclipse.recommenders.rcp.SharedImages;
import org.eclipse.recommenders.utils.Logs;
import org.eclipse.ui.IEditorPart;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;

@SuppressWarnings({ "restriction", "rawtypes" })
public class IntelligentCompletionProposalComputer extends JavaAllCompletionProposalComputer
        implements ICompletionListener, ICompletionListenerExtension2 {

    /**
     * A whitelist ensuring that the CompilationUnitEditor we are dealing with actually contains Java code. This is
     * necessary as certain plugins (Groovy Eclipse, Scala IDE) extend the JDT's CompilationUnitEditor.
     *
     * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=470372">Bug 470372</a>
     * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=470406">Bug 470406</a>
     * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=474318">Bug 474318</a>
     */
    private static final List<String> JAVA_EDITOR_WHITELIST = ImmutableList.of(CompilationUnitEditor.class.getName(),
            "org.eclipse.wb.internal.core.editor.multi.DesignerEditor");

    private final CompletionRcpPreferences preferences;
    private final IAstProvider astProvider;
    private final SharedImages images;
    private final Map<CompletionContextKey, ICompletionContextFunction> functions;
    private final Provider<IEditorPart> editorProvider;
    private final IProcessableProposalFactory proposalFactory = new ProcessableProposalFactory();

    private final Set<SessionProcessor> processors = Sets.newLinkedHashSet();
    private final Set<SessionProcessor> activeProcessors = Sets.newLinkedHashSet();

    // Set in storeContext
    public JavaContentAssistInvocationContext jdtContext;
    public IRecommendersCompletionContext crContext;

    public ContentAssistantFacade contentAssist;

    @Inject
    public IntelligentCompletionProposalComputer(CompletionRcpPreferences preferences, IAstProvider astProvider,
            SharedImages images, Map<CompletionContextKey, ICompletionContextFunction> functions,
            Provider<IEditorPart> editorRetriever) {
        this.preferences = preferences;
        this.astProvider = astProvider;
        this.images = images;
        this.functions = functions;
        this.editorProvider = editorRetriever;
    }

    @Override
    public void sessionStarted() {
        processors.clear();
        for (SessionProcessorDescriptor d : preferences.getEnabledSessionProcessors()) {
            try {
                processors.add(d.getProcessor());
            } catch (Throwable e) {
                log(ERROR_SESSION_PROCESSOR_FAILED, e, d.getId());
            }
        }
        activeProcessors.clear();
        activeProcessors.addAll(processors);
        // code looks odd? This method unregisters this instance from the last(!) source viewer see
        // unregisterCompletionListener for details
        unregisterCompletionListener();
    }

    @Override
    public List<ICompletionProposal> computeCompletionProposals(ContentAssistInvocationContext context,
            IProgressMonitor monitor) {

        if (!(context instanceof JavaContentAssistInvocationContext)) {
            return Collections.emptyList();
        }

        storeContext(context);

        if (!isTriggeredInJavaProject()) {
            // We can't make recommendations. Fall back to JDT.
            if (!isContentAssistConfigurationOkay()) {
                // JDT is still active, so don't add any proposals.
                return Collections.emptyList();
            } else {
                // JDT is inactive. Return all proposals JDT would have made.
                List<ICompletionProposal> res = Lists.newLinkedList();
                for (Entry<IJavaCompletionProposal, CompletionProposal> pair : crContext.getProposals().entrySet()) {
                    IJavaCompletionProposal jdtProposal = create(pair.getValue(), pair.getKey(), jdtContext,
                            proposalFactory);
                    res.add(jdtProposal);
                }
                return res;
            }
        }

        if (!isContentAssistConfigurationOkay()) {
            enableRecommenders();
            int offset = context.getInvocationOffset();
            EnabledCompletionProposal info = new EnabledCompletionProposal(images, offset);
            boolean hasOtherProposals = !crContext.getProposals().isEmpty();
            if (hasOtherProposals) {
                // Return the configure proposal
                return ImmutableList.<ICompletionProposal>of(info);
            } else {
                return ImmutableList.<ICompletionProposal>of(info, new EmptyCompletionProposal(offset));
            }
        } else {
            List<ICompletionProposal> res = Lists.newLinkedList();
            registerCompletionListener();
            crContext.set(ACTIVE_PROCESSORS, ImmutableSet.copyOf(activeProcessors));
            fireInitializeContext(crContext);
            fireStartSession(crContext);
            for (Entry<IJavaCompletionProposal, CompletionProposal> pair : crContext.getProposals().entrySet()) {
                IJavaCompletionProposal jdtProposal = create(pair.getValue(), pair.getKey(), jdtContext,
                        proposalFactory);
                res.add(jdtProposal);
                if (jdtProposal instanceof JavaMethodCompletionProposal) {
                    int position = guessContextInformationPosition(jdtContext);
                    JavaMethodCompletionProposal jmcp = (JavaMethodCompletionProposal) jdtProposal;
                    jmcp.setContextInformationPosition(position);
                }
                if (jdtProposal instanceof IProcessableProposal) {
                    IProcessableProposal crProposal = (IProcessableProposal) jdtProposal;
                    crProposal.setTag(CONTEXT, crContext);
                    crProposal.setTag(IS_VISIBLE, true);
                    crProposal.setTag(JDT_UI_PROPOSAL, pair.getKey());
                    crProposal.setTag(JDT_CORE_PROPOSAL, pair.getValue());
                    crProposal.setTag(JDT_SCORE, jdtProposal.getRelevance());
                    fireProcessProposal(crProposal);
                }
            }
            fireEndComputation(res);
            fireAboutToShow(res);

            return res;
        }
    }

    private boolean isTriggeredInJavaProject() {
        if (jdtContext == null) {
            return false;
        }

        IEditorPart editor = editorProvider.get();
        if (editor == null) {
            return false;
        }

        if (!JAVA_EDITOR_WHITELIST.contains(editor.getClass().getName())) {
            return false;
        }

        IJavaProject project = jdtContext.getProject();
        if (project == null) {
            return false;
        }
        return project.exists();
    }

    private void enableRecommenders() {
        new DisableContentAssistCategoryJob(MYLYN_ALL_CATEGORY).schedule();
        new DisableContentAssistCategoryJob(JDT_ALL_CATEGORY).schedule();
        new DisableContentAssistCategoryJob(JDT_TYPE_CATEGORY).schedule();
        new DisableContentAssistCategoryJob(JDT_NON_TYPE_CATEGORY).schedule();
    }

    @Override
    public void sessionEnded() {
        fireAboutToClose();
    }

    private void storeContext(ContentAssistInvocationContext context) {
        jdtContext = cast(context);
        crContext = new RecommendersCompletionContext(jdtContext, astProvider, functions);
    }

    protected boolean isContentAssistConfigurationOkay() {
        Set<String> excludedCategories = Sets.newHashSet(PreferenceConstants.getExcludedCompletionProposalCategories());
        if (excludedCategories.contains(RECOMMENDERS_ALL_CATEGORY_ID)) {
            // If we are excluded on the default tab, then we cannot be on the default tab now, as we are executing.
            // Hence, we must be on a subsequent tab.
            return true;
        }
        if (isJdtJavaProposalsEnabled(excludedCategories) || isMylynJavaProposalsEnabled(excludedCategories)) {
            return false;
        }
        return true;
    }

    private boolean isMylynJavaProposalsEnabled(Set<String> excludedCategories) {
        return isMylynInstalled() && !excludedCategories.contains(MYLYN_ALL_CATEGORY);
    }

    private boolean isJdtJavaProposalsEnabled(Set<String> excludedCategories) {
        return !excludedCategories.contains(JDT_ALL_CATEGORY) || !excludedCategories.contains(JDT_TYPE_CATEGORY)
                || !excludedCategories.contains(JDT_NON_TYPE_CATEGORY);
    }

    private boolean isMylynInstalled() {
        CompletionProposalComputerRegistry reg = CompletionProposalComputerRegistry.getDefault();
        for (CompletionProposalCategory cat : reg.getProposalCategories()) {
            if (cat.getId().equals(MYLYN_ALL_CATEGORY)) {
                return true;
            }
        }
        return false;
    }

    private void registerCompletionListener() {
        ITextViewer v = jdtContext.getViewer();
        if (!(v instanceof SourceViewer)) {
            return;
        }
        SourceViewer sv = (SourceViewer) v;
        contentAssist = sv.getContentAssistantFacade();
        contentAssist.addCompletionListener(this);
    }

    /*
     * Unregisters this computer from the last known content assist facade. This method is called in some unexpected
     * places (i.e., not in sessionEnded and similar methods) because unregistering in these methods would be too early
     * to get notified about apply events.
     */
    private void unregisterCompletionListener() {
        if (contentAssist != null) {
            contentAssist.removeCompletionListener(this);
        }
    }

    protected void fireInitializeContext(IRecommendersCompletionContext crContext) {
        for (Iterator<SessionProcessor> it = activeProcessors.iterator(); it.hasNext();) {
            SessionProcessor p = it.next();
            try {
                p.initializeContext(crContext);
            } catch (Throwable e) {
                it.remove();
                Logs.log(ERROR_SESSION_PROCESSOR_FAILED, e, p.getClass());
            }
        }
    }

    protected void fireStartSession(IRecommendersCompletionContext crContext) {
        for (Iterator<SessionProcessor> it = activeProcessors.iterator(); it.hasNext();) {
            SessionProcessor p = it.next();
            try {
                boolean interested = p.startSession(crContext);
                if (!interested) {
                    it.remove();
                }
            } catch (Throwable e) {
                it.remove();
                Logs.log(ERROR_SESSION_PROCESSOR_FAILED, e, p.getClass());
            }
        }
    }

    protected void fireProcessProposal(IProcessableProposal proposal) {
        for (SessionProcessor p : activeProcessors) {
            try {
                proposal.getRelevance();
                p.process(proposal);
            } catch (Throwable e) {
                log(ERROR_SESSION_PROCESSOR_FAILED, e, p.getClass());
            }
        }
        proposal.getProposalProcessorManager().prefixChanged(crContext.getPrefix());
    }

    protected void fireEndComputation(List<ICompletionProposal> proposals) {
        for (SessionProcessor p : activeProcessors) {
            try {
                p.endSession(proposals);
            } catch (Throwable e) {
                log(ERROR_SESSION_PROCESSOR_FAILED, e, p.getClass());
            }
        }
    }

    protected void fireAboutToShow(List<ICompletionProposal> proposals) {
        for (SessionProcessor p : activeProcessors) {
            try {
                p.aboutToShow(proposals);
            } catch (Throwable e) {
                log(ERROR_SESSION_PROCESSOR_FAILED, e, p.getClass());
            }
        }
    }

    protected void fireAboutToClose() {
        for (SessionProcessor p : activeProcessors) {
            try {
                p.aboutToClose();
            } catch (Throwable e) {
                log(ERROR_SESSION_PROCESSOR_FAILED, e, p.getClass());
            }
        }
    }

    @Override
    public void assistSessionStarted(ContentAssistEvent event) {
        // ignore
    }

    @Override
    public void assistSessionEnded(ContentAssistEvent event) {
        // ignore

        // Calling unregister here seems like a good choice here but unfortunately isn't. "proposal applied" events are
        // fired after the sessionEnded event, and thus, we cannot use this method to unsubscribe from the current
        // editor. See unregisterCompletionListern for details.
    }

    @Override
    public void selectionChanged(ICompletionProposal proposal, boolean smartToggle) {
        for (SessionProcessor p : activeProcessors) {
            try {
                p.selected(proposal);
            } catch (Throwable e) {
                log(ERROR_SESSION_PROCESSOR_FAILED, e, p.getClass());
            }
        }
    }

    @Override
    public void applied(ICompletionProposal proposal) {
        for (SessionProcessor p : activeProcessors) {
            try {
                p.applied(proposal);
            } catch (Throwable e) {
                log(ERROR_SESSION_PROCESSOR_FAILED, e, p.getClass());
            }
        }
        unregisterCompletionListener();
    }
}