PerlCompletionProcessor.java

package org.epic.perleditor.editors.perl;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.text.*;
import org.eclipse.jface.text.contentassist.*;
import org.eclipse.ui.editors.text.TextEditor;
import org.epic.core.model.ISourceElement;
import org.epic.core.util.PerlExecutor;
import org.epic.perleditor.PerlEditorPlugin;
import org.epic.perleditor.editors.PartitionTypes;
import org.epic.perleditor.editors.PerlPartitioner;
import org.epic.perleditor.preferences.CodeAssistPreferences;
import org.epic.perleditor.templates.*;
import org.epic.perleditor.templates.perl.*;

/**
 * Perl completion processor.
 */
public class PerlCompletionProcessor implements IContentAssistProcessor
{        
    private static final IPerlCompletionProposal[] NO_PROPOSALS =
        new IPerlCompletionProposal[0];
    
    // public to enable unit testing
    public static Pattern MODULE_PREFIX_PATTERN = Pattern.compile("([A-Za-z0-9_]+(::|->))+");
    public static Pattern VAR_PREFIX_PATTERN = Pattern.compile("\\$[A-Za-z0-9_]+(::|->)$");
    
    private final IContextInformationValidator fValidator = new Validator();
    private final PerlCompletionProposalComparator fComparator = new PerlCompletionProposalComparator();    
    private final TextEditor fTextEditor;
    private final TemplateEngine fTemplateEngine;

    public PerlCompletionProcessor(TextEditor textEditor) 
    {
        fTextEditor = textEditor;

        ContextType contextType = getContextType();
        if (contextType != null) fTemplateEngine = new TemplateEngine(contextType);
        else fTemplateEngine = null;
    }

    public ICompletionProposal[] computeCompletionProposals(
        ITextViewer viewer, int documentOffset)
    {
        // get the current document's text, up to caret position
        IDocument document = viewer.getDocument();
        ITextSelection selection = (ITextSelection) viewer.getSelectionProvider().getSelection();        
        if (selection.getLength() > 0) return NO_PROPOSALS;

        String lastTextLine = null;
        try
        {
            int lastLine = document.getLineOfOffset(documentOffset);
            int lineStartOffset = document.getLineOffset(lastLine);
            lastTextLine = document.get(
                lineStartOffset, documentOffset - lineStartOffset);
        }
        catch (BadLocationException ble)
        {
            // TODO what to do here?
        }

        String moduleNamePrefix = getModuleNamePrefix(lastTextLine); 
        if (moduleNamePrefix != null)
        {
            return computeModuleNameProposals(
                viewer, documentOffset, moduleNamePrefix);
        }
        else
        {
            String className = getClassName(documentOffset, document);
            return className != null
                ? computeMethodProposals(viewer, documentOffset, className)
                : sort(concatenate(
                    computeVariableProposals(viewer, documentOffset),
                    computeTemplateProposals(viewer, documentOffset)
                    ));
        }
    }
    
    public IContextInformation[] computeContextInformation(
        ITextViewer viewer,
        int documentOffset)
    {
        return null;
    }

    public char[] getCompletionProposalAutoActivationCharacters()
    {
        String activationChars  = PerlEditorPlugin.getDefault().getPreferenceStore().getString(CodeAssistPreferences.AUTO_ACTIVATION_CHARS);
        return activationChars.toCharArray();
    }

    public char[] getContextInformationAutoActivationCharacters()
    {
        return null;
    }

    public IContextInformationValidator getContextInformationValidator()
    {
        return fValidator;
    }

    public String getErrorMessage()
    {
        return null;
    }

    private ICompletionProposal[] computeMethodProposals(
        ITextViewer viewer, int documentOffset, String className)
    {
        List proposals = getProposalsForClassname(className);
        ContextType contextType = getContextType();
        if (contextType != null)
        {
            SubroutineEngine subroutineEngine = new SubroutineEngine(contextType);
            subroutineEngine.complete(
                viewer,
                documentOffset,
                (String[]) proposals.toArray(new String[proposals.size()]));
            return subroutineEngine.getResults();
        }
        else return new IPerlCompletionProposal[0];
    }
    
    private ICompletionProposal[] computeModuleNameProposals(
        ITextViewer viewer, int documentOffset, String moduleNamePrefix)
    {   
        ModuleCompletionHelper completionHelper = ModuleCompletionHelper.getInstance();
        return completionHelper.getProposals(moduleNamePrefix, documentOffset, viewer);
    }
    
    private IPerlCompletionProposal[] computeTemplateProposals(
        ITextViewer viewer, int documentOffset)
    {
        fTemplateEngine.reset();
        fTemplateEngine.complete(viewer, documentOffset);
        return fTemplateEngine.getResults();
    }

    private IPerlCompletionProposal[] computeVariableProposals(ITextViewer viewer, int documentOffset)
    {
        if (!PerlEditorPlugin.getDefault().getPreferenceStore().getBoolean(
            CodeAssistPreferences.INSPECT_VARIABLES)) return NO_PROPOSALS;
        
        ContextType contextType = getContextType();
        if (contextType == null) return NO_PROPOSALS;

        Set variables = getCompletionVariables(viewer, documentOffset);

        VariableEngine varsEngine = new VariableEngine(contextType);

        varsEngine.complete(
            viewer,
            documentOffset,
            (String[]) variables.toArray(new String[variables.size()]));

        return varsEngine.getResults();
    }

    /**
     * Gets variable/filedescriptor info from source file
     */
    private Set getCompletionVariables(
        ITextViewer viewer, int documentOffset)
    {
        List variablesModel = new ArrayList();
        Set variables = new HashSet();

        String variableChars = "%$@";
        String filehandleChars = "<";

        try
        {
            documentOffset = getCompletionStartOffset(
                viewer.getDocument(),
                documentOffset,
                variableChars + filehandleChars);

            if (documentOffset < viewer.getDocument().getLength())
            {
                String key = viewer.getDocument().get(documentOffset, 1);
                if (variableChars.indexOf(key) != -1)
                {
                    variablesModel = getVariableElements(viewer, documentOffset);
                }
                else if (filehandleChars.indexOf(key) != -1)
                {
                    variablesModel =
                        SourceParser.getElements(
                            viewer.getDocument(),
                            "open[a-z]*\\s*?\\s*?[(]\\s*?([A-Z_0-9]+)\\s*?[,]",
                            "<",
                            ">",
                            true);
                }
            }

            for (Iterator i = variablesModel.iterator(); i.hasNext();)
            {
                ISourceElement elem = (ISourceElement) i.next();
                String name = elem.getName();

                // Only insert variables once
                if (!variables.contains(name))
                {
                    variables.add(name);

                    if (name.startsWith("@"))
                        variables.add("$" + name.substring(1) + "[]");
                    else if (name.startsWith("%"))
                        variables.add("$" + name.substring(1) + "{}");
                }
            }
        }
        catch (BadLocationException ex)
        {
            ex.printStackTrace(); // TODO log it
        }
        return variables;
    }
    
    private List getVariableElements(ITextViewer viewer, int documentOffset)
        throws BadLocationException
    {
        IDocument doc = viewer.getDocument();
        IDocumentPartitioner p = 
            ((IDocumentExtension3) doc).getDocumentPartitioner(
                PartitionTypes.PERL_PARTITIONING);
        
        if (!(p instanceof PerlPartitioner)) return Collections.EMPTY_LIST;

        ITypedRegion[] regions =
            ((PerlPartitioner) p)
            .computePartitioning(0, documentOffset);
        
        List elements = new ArrayList();

        for (int i = 0; i < regions.length; i++)
        {
            if (regions[i].getType().equals(PartitionTypes.VARIABLE))
            {
                String name = doc.get(regions[i].getOffset(), regions[i].getLength());
                if (name.length() > 1 && name.charAt(1) == '{') continue; // ignore ${@foo} and the like
                elements.add(new SourceElement(
                    name, regions[i].getOffset(), regions[i].getLength()));
            }
        }
        return elements;
    }

    private String getClassName(int documentOffset, IDocument document)
    {
        try
        {
            // Find offset just after the -> or :: for which completion is requested 
            documentOffset =
                getCompletionStartOffset(document, documentOffset, "_");

            String text = document.get(0, documentOffset);
            if (!text.endsWith("->") && !text.endsWith("::")) return null;

            // Get the object name
            int lineNo = document.getLineOfOffset(documentOffset);
            String line = text.substring(document.getLineOffset(lineNo));

            // Lines can end with "->" of "::"
            if (VAR_PREFIX_PATTERN.matcher(line).find())
            {
                String objName = line.substring(line.lastIndexOf('$'));

                objName = objName.indexOf("->") != -1
                    ? objName.substring(0, objName.indexOf("->"))
                    : objName.substring(0, objName.indexOf("::"));
                
                String className = findTypedLexical(objName, text);
                if (className == null) className = findConstructorCall(objName, text);

                return className;
            }
            else
            {
                Matcher m = MODULE_PREFIX_PATTERN.matcher(line);
                if (m.find())
                {
                    // strip -> or :: from the end
                    String str = m.group(0);
                    return str.substring(0, str.length()-2); 
                }
                else return null;
            }
        }
        catch (Exception ex)
        {
            return null; // TODO error handling
        }
    }

    private String findConstructorCall(String objName, String text)
    {
        // Try to find something like "my $foo = Some::Class->..."
        Pattern p = Pattern.compile("\\" + objName + "\\s*=\\s*([a-zA-Z:->0-9_]+)(->|::|;)");
        Matcher m = p.matcher(text);
        String className = null;
        while (m.find()) className = m.group(1);
        return className;
    }
    
    private String findTypedLexical(String objName, String text)
    {        
        // Try to find typed lexical like "my Some::Class $foo = ...;"
        // or "my __PACKAGE__ $foo = ...;"
        Pattern p = Pattern.compile("my\\s+(\\S+)\\s+\\" + objName + "\\s*=");
        Matcher m = p.matcher(text);
        int foundAt = -1;
        String className = null;
        while (m.find())
        {
            className = m.group(1);
            foundAt = m.start(1);
        }                
        if (className != null)
        {
            if ("__PACKAGE__".equals(className)) 
            {
                // Find most recent "package ...;" line before
                // the typed lexical was introduced
                p = Pattern.compile("\\s*package\\s+(\\S+)\\s*;");
                m = p.matcher(text);
                
                while (m.find() && m.start(1) < foundAt)
                    className = m.group(1);
                
                // not found? bad luck
                if ("__PACKAGE__".equals(className)) return null;
            }
        }
        return className;
    }
    
    private List getProposalsForClassname(String className)
    {
        String perlCode =
            "use "
                + className
                + ";\n\n"
                + "@classes = qw(" + className + ");\n"
                + "push(@classes, @" + className + "::ISA);\n"
                + "foreach $class (@classes) {\n"
                + "next if ($class eq 'Exporter');\n"
                + "%symtab = eval '%'.$class.'::';\n"
                + "foreach $name (keys %symtab) {\n"
                + " next if($name !~ /[a-z]/ || $name =~ /^_/);\n"
                + "   if(defined &{$class.'::'.$name}) {\n"
                + "       $proposals{$name.'()'} = 1;\n"
                + "   }\n"
                + "}}\n"
                + "print join(\"\\n\", sort keys %proposals);";

        PerlExecutor executor = new PerlExecutor();
        try
        {
            return executor.execute(fTextEditor, null, perlCode).getStdoutLines();
        }
        catch (CoreException e)
        {
            PerlEditorPlugin.getDefault().getLog().log(e.getStatus());
            return new ArrayList();
        }
        finally
        {
            executor.dispose();
        }
    }

    /**
     * Orders the given proposals.
     */
    private IPerlCompletionProposal[] sort(IPerlCompletionProposal[] proposals)
    {
        Arrays.sort(proposals, fComparator);
        return proposals;
    }

    /**
     * Finds the content assist start offset: the offset just after
     * the sequence of characters triggering the completion. For example,
     * if the completion was requested after typing "$foo->ab", the method
     * would return the offset just after "$foo->".
     *
     * @param document      document in which completion was requested
     * @param caretOffset   offset at which completion was requested
     * @return offset
     */
    private int getCompletionStartOffset(
        IDocument document,
        int caretOffset,
        String specialChars)
        throws BadLocationException
    {
        while (stepLeft(document, caretOffset, specialChars)) caretOffset--;
        if (stepLeft(document, caretOffset, specialChars)) caretOffset--;
        return caretOffset;
    }
    
    private ContextType getContextType()
    {
        return ContextTypeRegistry.getInstance().getContextType("perl"); //$NON-NLS-1$
    }
    
    private String getModuleNamePrefix(String line)
    {
        Pattern pattern = Pattern.compile(
            "\\s*use[ \\t]+(\\S*)\\s*$", Pattern.MULTILINE | Pattern.DOTALL);
        Matcher matcher = pattern.matcher(line);
        return matcher.matches() ? matcher.group(1) : null;
    }
    
    private boolean stepLeft(IDocument doc, int offset, String specialChars)
        throws BadLocationException
    {
        return
            offset != 0 &&
            (Character.isUnicodeIdentifierPart(doc.getChar(offset - 1)) ||
            specialChars.indexOf(doc.getChar(offset - 1)) != -1);
    }
    
    private static IPerlCompletionProposal[] concatenate(
        IPerlCompletionProposal[] a,
        IPerlCompletionProposal[] b)
    {   
        IPerlCompletionProposal[] result =
            new IPerlCompletionProposal[b.length + a.length];
        System.arraycopy(b, 0, result, 0, b.length);
        System.arraycopy(a, 0, result, b.length, a.length);
        return result;
    }

    /**
     * Simple content assist tip closer. The tip is valid in a range
     * of 5 characters around its popup location.
     */
    private static class Validator
        implements IContextInformationValidator, IContextInformationPresenter
    {
        protected int fInstallOffset;

        public boolean isContextInformationValid(int offset)
        {
            return Math.abs(fInstallOffset - offset) < 5;
        }

        public void install(
            IContextInformation info,
            ITextViewer viewer,
            int offset)
        {
            fInstallOffset = offset;
        }

        public boolean updatePresentation(
            int documentPosition,
            TextPresentation presentation)
        {
            return false;
        }
    }
}