Examples with CompletionCache org.python.pydev.ast.codecompletion.revisited.CompletionCache used on opensource projects

Example 1 with CompletionCache

use of org.python.pydev.ast.codecompletion.revisited.CompletionCache in project Pydev by fabioz.

the class TddCodeGenerationQuickFixParticipant method checkCreationBasedOnFoundPointers.

public boolean checkCreationBasedOnFoundPointers(PyEdit edit, PySelection callPs, List<ICompletionProposalHandle> ret, TddPossibleMatches possibleMatch, ItemPointer[] pointers, String methodToCreate, PySelection newSelection, IPythonNature nature) throws MisconfigurationException, Exception {
    CompletionCache completionCache = new CompletionCache();
    for (ItemPointer pointer : pointers) {
        Definition definition = pointer.definition;
        try {
            definition = rebaseToClassDefDefinition(nature, completionCache, definition, null);
        } catch (CompletionRecursionException e) {
            // Just keep going.
            Log.log(e);
        }
        if (definition.ast instanceof ClassDef) {
            ClassDef d = (ClassDef) definition.ast;
            String fullName = NodeUtils.getRepresentationString(d) + "." + methodToCreate;
            IToken repInModule = nature.getAstManager().getRepInModule(definition.module, fullName, nature);
            if (repInModule != null) {
                // System.out.println("Skipping creation of: " + fullName); //We found it, so, don't suggest it.
                continue;
            }
            for (Boolean isCall : new Boolean[] { true, false }) {
                // Give the user a chance to create the method we didn't find.
                PyCreateMethodOrField pyCreateMethod = new PyCreateMethodOrField();
                List<String> parametersAfterCall = null;
                parametersAfterCall = configCreateAsAndReturnParametersAfterCall(callPs, isCall, pyCreateMethod, parametersAfterCall, methodToCreate);
                String className = NodeUtils.getRepresentationString(d);
                pyCreateMethod.setCreateInClass(className);
                String displayString = StringUtils.format("Create %s %s at %s (%s)", methodToCreate, pyCreateMethod.getCreationStr(), className, definition.module.getName());
                TddRefactorCompletionInModule completion = new TddRefactorCompletionInModule(methodToCreate, tddQuickFixParticipant != null ? tddQuickFixParticipant.imageMethod : null, displayString, null, displayString, IPyCompletionProposal.PRIORITY_CREATE, edit, definition.module.getFile(), parametersAfterCall, pyCreateMethod, newSelection);
                completion.locationStrategy = AbstractPyCreateAction.LOCATION_STRATEGY_END;
                ret.add(completion);
            }
            return true;
        }
    }
    return false;
}

Example 2 with CompletionCache

use of org.python.pydev.ast.codecompletion.revisited.CompletionCache in project Pydev by fabioz.

the class TddQuickFixParticipant method addProps.

@Override
public void addProps(MarkerAnnotationAndPosition markerAnnotation, IAnalysisPreferences analysisPreferences, String line, PySelection ps, int offset, IPythonNature nature, PyEdit edit, List<ICompletionProposalHandle> props) throws BadLocationException, CoreException {
    if (nature == null) {
        return;
    }
    ICodeCompletionASTManager astManager = nature.getAstManager();
    if (astManager == null) {
        return;
    }
    if (markerAnnotation.position == null) {
        return;
    }
    IMarker marker = markerAnnotation.markerAnnotation.getMarker();
    Integer id = (Integer) marker.getAttribute(AnalysisRunner.PYDEV_ANALYSIS_TYPE);
    int start = markerAnnotation.position.offset;
    int end = start + markerAnnotation.position.length;
    ps.setSelection(start, end);
    String markerContents;
    try {
        markerContents = ps.getSelectedText();
    } catch (Exception e1) {
        // Selection may be wrong.
        return;
    }
    IDocument doc = ps.getDoc();
    List<String> parametersAfterCall = ps.getParametersAfterCall(end);
    switch(id) {
        case IAnalysisPreferences.TYPE_UNDEFINED_VARIABLE:
            addCreateClassOption(ps, edit, props, markerContents, parametersAfterCall);
            addCreateMethodOption(ps, edit, props, markerContents, parametersAfterCall);
            break;
        case IAnalysisPreferences.TYPE_UNDEFINED_IMPORT_VARIABLE:
            // Say we had something as:
            // import sys
            // sys.Bar
            // in which case 'Bar' is undefined
            // in this situation, the activationTokenAndQual would be "sys." and "Bar"
            // and we want to get the definition for "sys"
            String[] activationTokenAndQual = ps.getActivationTokenAndQualifier(true);
            if (activationTokenAndQual[0].endsWith(".")) {
                ArrayList<IDefinition> selected = findDefinitions(nature, edit, start - 2, doc);
                for (IDefinition iDefinition : selected) {
                    IModule module = iDefinition.getModule();
                    if (module.getFile() != null) {
                        Definition definition = (Definition) iDefinition;
                        File file = module.getFile();
                        if (definition.ast == null) {
                            // if we have no ast in the definition, it means the module itself was found (global scope)
                            // Add option to create class at the given module!
                            addCreateClassOption(ps, edit, props, markerContents, parametersAfterCall, file);
                            addCreateMethodOption(ps, edit, props, markerContents, parametersAfterCall, file);
                        } else if (definition.ast instanceof ClassDef) {
                            ClassDef classDef = (ClassDef) definition.ast;
                            // Ok, we should create a field or method in this case (accessing a classmethod or staticmethod)
                            PyCreateMethodOrField pyCreateMethod = new PyCreateMethodOrField();
                            String className = NodeUtils.getNameFromNameTok(classDef.name);
                            pyCreateMethod.setCreateInClass(className);
                            pyCreateMethod.setCreateAs(PyCreateMethodOrField.CLASSMETHOD);
                            addCreateClassmethodOption(ps, edit, props, markerContents, parametersAfterCall, pyCreateMethod, file, className);
                        }
                    }
                }
            }
            break;
        case IAnalysisPreferences.TYPE_UNRESOLVED_IMPORT:
            // This case is the following: from other_module4 import Foo
            // with 'Foo' being undefined.
            // So, we have to suggest creating a Foo class/method in other_module4
            PyImportsHandling importsHandling = new PyImportsHandling(ps.getDoc(), false);
            int offsetLine = ps.getLineOfOffset(start);
            String selectedText = ps.getSelectedText();
            Tuple<IModule, String> found = null;
            String foundFromImportStr = null;
            boolean isImportFrom = false;
            OUT: for (ImportHandle handle : importsHandling) {
                if (handle.startFoundLine == offsetLine || handle.endFoundLine == offsetLine || (handle.startFoundLine < offsetLine && handle.endFoundLine > offsetLine)) {
                    List<ImportHandleInfo> importInfo = handle.getImportInfo();
                    for (ImportHandleInfo importHandleInfo : importInfo) {
                        String fromImportStr = importHandleInfo.getFromImportStr();
                        List<String> importedStr = importHandleInfo.getImportedStr();
                        for (String imported : importedStr) {
                            if (selectedText.equals(imported)) {
                                if (fromImportStr != null) {
                                    foundFromImportStr = fromImportStr + "." + imported;
                                    isImportFrom = true;
                                } else {
                                    // if fromImportStr == null, it's not a from xxx import yyy (i.e.: simple import)
                                    foundFromImportStr = imported;
                                }
                                try {
                                    String currentModule = nature.resolveModule(edit.getEditorFile());
                                    ICompletionState state = CompletionStateFactory.getEmptyCompletionState(nature, new CompletionCache());
                                    found = nature.getAstManager().findModule(foundFromImportStr, currentModule, state, new SourceModule(currentModule, edit.getEditorFile(), edit.getAST(), null, nature));
                                } catch (Exception e) {
                                    Log.log(e);
                                }
                                break OUT;
                            }
                        }
                    }
                    break OUT;
                }
            }
            boolean addOptionToCreateClassOrMethod = isImportFrom;
            if (found != null && found.o1 != null) {
                // or just create a class or method at the end.
                if (found.o1 instanceof SourceModule) {
                    // if all was found, there's nothing left to create.
                    if (found.o2 != null && found.o2.length() > 0) {
                        SourceModule sourceModule = (SourceModule) found.o1;
                        File file = sourceModule.getFile();
                        if (found.o2.indexOf('.') != -1) {
                            // We have to create some intermediary structure.
                            if (!addOptionToCreateClassOrMethod) {
                                // Cannot create class or method from the info (only the module structure).
                                if (sourceModule.getName().endsWith(".__init__")) {
                                    File f = getFileStructure(file.getParentFile(), found.o2);
                                    addCreateModuleOption(ps, edit, props, markerContents, f);
                                }
                            } else {
                                // Ok, the leaf may be a class or method.
                                if (sourceModule.getName().endsWith(".__init__")) {
                                    String moduleName = FullRepIterable.getWithoutLastPart(sourceModule.getName());
                                    String withoutLastPart = FullRepIterable.getWithoutLastPart(found.o2);
                                    moduleName += "." + withoutLastPart;
                                    String classOrMethodName = FullRepIterable.getLastPart(found.o2);
                                    File f = getFileStructure(file.getParentFile(), withoutLastPart);
                                    addCreateClassInNewModuleOption(ps, edit, props, classOrMethodName, moduleName, parametersAfterCall, f);
                                    addCreateMethodInNewModuleOption(ps, edit, props, classOrMethodName, moduleName, parametersAfterCall, f);
                                }
                            }
                        } else {
                            // Ok, it's all there, we just have to create the leaf.
                            if (!addOptionToCreateClassOrMethod || sourceModule.getName().endsWith(".__init__")) {
                                // Cannot create class or method from the info (only the module structure).
                                if (sourceModule.getName().endsWith(".__init__")) {
                                    File f = new File(file.getParent(), found.o2 + FileTypesPreferences.getDefaultDottedPythonExtension());
                                    addCreateModuleOption(ps, edit, props, markerContents, f);
                                }
                            } else {
                                // Ok, the leaf may be a class or method.
                                addCreateClassOption(ps, edit, props, markerContents, parametersAfterCall, file);
                                addCreateMethodOption(ps, edit, props, markerContents, parametersAfterCall, file);
                            }
                        }
                    }
                }
            } else if (foundFromImportStr != null) {
                // We couldn't find anything there, so, we have to create the modules structure as needed and
                // maybe create a class or module at the end (but only if it's an import from).
                // Ok, it's all there, we just have to create the leaf.
                // Discover the source folder where we should create the structure.
                File editorFile = edit.getEditorFile();
                String onlyProjectPythonPathStr = nature.getPythonPathNature().getOnlyProjectPythonPathStr(false);
                List<String> split = StringUtils.splitAndRemoveEmptyTrimmed(onlyProjectPythonPathStr, '|');
                for (int i = 0; i < split.size(); i++) {
                    String fullPath = FileUtils.getFileAbsolutePath(split.get(i));
                    fullPath = PythonPathHelper.getDefaultPathStr(fullPath);
                    split.set(i, fullPath);
                }
                HashSet<String> projectSourcePath = new HashSet<String>(split);
                if (projectSourcePath.size() == 0) {
                    // No source folder for editor... this shouldn't happen (code analysis wouldn't even run on it).
                    return;
                }
                String fullPath = FileUtils.getFileAbsolutePath(editorFile);
                fullPath = PythonPathHelper.getDefaultPathStr(fullPath);
                String foundSourceFolderFullPath = null;
                if (projectSourcePath.size() == 1) {
                    foundSourceFolderFullPath = projectSourcePath.iterator().next();
                } else {
                    for (String string : projectSourcePath) {
                        if (fullPath.startsWith(string)) {
                            // Use this as the source folder
                            foundSourceFolderFullPath = string;
                            break;
                        }
                    }
                }
                if (foundSourceFolderFullPath != null) {
                    if (!addOptionToCreateClassOrMethod) {
                        // Cannot create class or method from the info (only the module structure).
                        File f = getFileStructure(new File(foundSourceFolderFullPath), foundFromImportStr);
                        addCreateModuleOption(ps, edit, props, foundFromImportStr, f);
                    } else {
                        // Ok, the leaf may be a class or method.
                        String moduleName = FullRepIterable.getWithoutLastPart(foundFromImportStr);
                        File file = getFileStructure(new File(foundSourceFolderFullPath), moduleName);
                        String lastPart = FullRepIterable.getLastPart(foundFromImportStr);
                        addCreateClassInNewModuleOption(ps, edit, props, lastPart, moduleName, parametersAfterCall, file);
                        addCreateMethodInNewModuleOption(ps, edit, props, lastPart, moduleName, parametersAfterCall, file);
                    }
                }
            }
            break;
    }
}

Example 3 with CompletionCache

use of org.python.pydev.ast.codecompletion.revisited.CompletionCache in project Pydev by fabioz.

the class ModuleAdapter method resolveClass.

/**
 * Get a class adapter for a given class contained in this module.
 *
 * @param name the name of the class we want to resolve.
 *
 * @return an adapter to the class.
 */
public IClassDefAdapter resolveClass(String name) {
    CompletionCache completionCache = new CompletionCache();
    HashSet<String> toResolve = new HashSet<String>();
    toResolve.add(name);
    Set<IClassDefAdapter> resolved;
    try {
        resolved = resolveImportedClass(toResolve, completionCache);
    } catch (MisconfigurationException e) {
        throw new RuntimeException(e);
    }
    if (toResolve.size() == 1) {
        return resolved.iterator().next();
    }
    return null;
}

Example 4 with CompletionCache

use of org.python.pydev.ast.codecompletion.revisited.CompletionCache in project Pydev by fabioz.

the class PyStringCodeCompletion method getCodeCompletionProposals.

/**
 * Needed interface for adding the completions on a request
 * @throws MisconfigurationException
 * @throws PythonNatureWithoutProjectException
 * @throws IOException
 */
@Override
public TokensOrProposalsList getCodeCompletionProposals(CompletionRequest request) throws CoreException, BadLocationException, MisconfigurationException, IOException, PythonNatureWithoutProjectException {
    List<ICompletionProposalHandle> completionProposals = new ArrayList<>();
    // don't show templates in strings
    request.showTemplates = false;
    fillWithEpydocFields(request, completionProposals);
    TokensOrProposalsList ret = new TokensOrProposalsList();
    if (completionProposals.size() == 0) {
        // if the size is not 0, it means that this is a place for the '@' stuff, and not for the 'default' context for a string.
        IDocument doc = request.doc;
        FastPartitioner fastPartitioner = ((FastPartitioner) PyPartitionScanner.checkPartitionScanner(doc));
        ITypedRegion partition = fastPartitioner.getPartition(request.documentOffset);
        String partitionType = partition.getType();
        if (IPythonPartitions.F_STRING_PARTITIONS.contains(partitionType)) {
            // Now we are going to check whether where we are in the given completion offset
            int requestOffset = request.documentOffset;
            int partitionOffset = partition.getOffset();
            int partitionLine = doc.getLineOfOffset(partitionOffset);
            int partitionCol = partitionOffset - doc.getLineOffset(partitionLine);
            String str = doc.get(partitionOffset, partition.getLength());
            FStringsAST ast = null;
            try {
                ast = FStringsGrammarFactory.createGrammar(str).f_string();
            } catch (Throwable e) {
            // Just ignore any errors for this.
            }
            if (ast != null && ast.hasChildren()) {
                for (SimpleNode node : ast.getBalancedExpressionsToBeEvaluatedInRegularGrammar()) {
                    int nodeOffset;
                    int nodeEndOffset;
                    if (node.beginLine > 1) {
                        nodeOffset = TextSelectionUtils.getAbsoluteCursorOffset(doc, partitionLine + node.beginLine - 1, node.beginColumn - 1);
                    } else {
                        nodeOffset = TextSelectionUtils.getAbsoluteCursorOffset(doc, partitionLine + node.beginLine - 1, partitionCol + node.beginColumn - 1);
                    }
                    if (node.endLine > 1) {
                        nodeEndOffset = TextSelectionUtils.getAbsoluteCursorOffset(doc, partitionLine + node.endLine - 1, node.endColumn);
                    } else {
                        nodeEndOffset = TextSelectionUtils.getAbsoluteCursorOffset(doc, partitionLine + node.endLine - 1, partitionCol + node.endColumn);
                    }
                    if (requestOffset >= nodeOffset && requestOffset <= nodeEndOffset) {
                        // request is inside a format, so we have to get a normal code completion to it
                        return new PyCodeCompletion().getCodeCompletionProposals(request);
                    }
                }
            }
        }
        PyCodeCompletionsForTypedDict pyCodeCompletionsForTypedDict = new PyCodeCompletionsForTypedDict(request);
        if (pyCodeCompletionsForTypedDict.isTypedDictCompletionRequest()) {
            // If it's a typed dict completion request, don't go into other requests.
            TokensOrProposalsList completionsForTypedDict;
            try {
                completionsForTypedDict = pyCodeCompletionsForTypedDict.getStringCompletions();
                if (completionsForTypedDict != null) {
                    return completionsForTypedDict;
                }
            } catch (CompletionRecursionException e) {
                Log.log(e);
            }
            return new TokensOrProposalsList();
        }
        TokensOrProposalsList stringGlobalsFromParticipants = getStringGlobalsFromParticipants(request, CompletionStateFactory.getEmptyCompletionState(request.activationToken, request.nature, new CompletionCache()));
        ret.addAll(stringGlobalsFromParticipants);
    // the code-below does not work well because the module may not have an actual import for the activation token,
    // so, it is useless too many times
    // if(request.activationToken.length() != 0){
    // PyCodeCompletion completion = new PyCodeCompletion();
    // ret.addAll(completion.getCodeCompletionProposals(viewer, request));
    // }
    }
    fillWithParams(request, completionProposals);
    ret.addAll(new TokensOrProposalsList(completionProposals));
    return ret;
}

Example 5 with CompletionCache

use of org.python.pydev.ast.codecompletion.revisited.CompletionCache in project Pydev by fabioz.

the class PyEdit method openWithPathAndInnerStructure.

/**
 * This function will open an editor given the passed parameters
 *
 * @param projectName
 * @param path
 * @param innerStructure
 * @throws MisconfigurationException
 */
public static void openWithPathAndInnerStructure(String projectName, IPath path, List<String> innerStructure) throws MisconfigurationException {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    IProject project = workspace.getRoot().getProject(projectName);
    if (project != null) {
        IFile file = project.getFile(path);
        if (file != null) {
            IEditorPart editor = PyOpenEditor.doOpenEditor(file);
            if (editor instanceof PyEdit) {
                PyEdit pyEdit = (PyEdit) editor;
                IPythonNature nature = pyEdit.getPythonNature();
                AbstractModule mod = AbstractModule.createModuleFromDoc(nature.resolveModule(file), file.getLocation().toFile(), pyEdit.getDocument(), nature, false);
                StringBuffer tok = new StringBuffer(80);
                for (String s : innerStructure) {
                    if (tok.length() > 0) {
                        tok.append('.');
                    }
                    tok.append(s);
                }
                try {
                    IDefinition[] definitions = mod.findDefinition(CompletionStateFactory.getEmptyCompletionState(tok.toString(), nature, new CompletionCache()), -1, -1, nature);
                    List<ItemPointer> pointers = new ArrayList<ItemPointer>();
                    PyRefactoringFindDefinition.getAsPointers(pointers, definitions);
                    if (pointers.size() > 0) {
                        new PyOpenAction().run(pointers.get(0));
                    }
                } catch (Exception e) {
                    Log.log(e);
                }
            }
        }
    }
}