@Override
protected void addCompletions(
@NotNull CompletionParameters completionParameters,
ProcessingContext processingContext,
@NotNull CompletionResultSet completionResultSet) {
if (!Symfony2ProjectComponent.isEnabled(completionParameters.getPosition())) {
return;
}
XmlEventParser xmlEventParser =
ServiceXmlParserFactory.getInstance(
completionParameters.getPosition().getProject(), XmlEventParser.class);
for (Map.Entry<String, String> event : xmlEventParser.get().entrySet()) {
completionResultSet.addElement(
LookupElementBuilder.create(event.getKey())
.withTypeText(event.getValue(), true)
.withIcon(Symfony2Icons.EVENT));
}
for (EventDispatcherSubscribedEvent event :
EventDispatcherSubscriberUtil.getSubscribedEvents(
completionParameters.getPosition().getProject())) {
completionResultSet.addElement(
LookupElementBuilder.create(event.getStringValue())
.withTypeText("EventSubscriber", true)
.withIcon(Symfony2Icons.EVENT));
}
}
public KeywordCompletionProvider() {
super();
for (String keyword : KEYWORDS) {
KEYWORD_LOOKUPS.add(LookupElementBuilder.create(keyword));
ATTR_LOOKUPS.add(LookupElementBuilder.create("n:" + keyword));
}
for (String filter : FILTERS) FILTER_LOOKUPS.add(LookupElementBuilder.create(filter));
}
@NotNull
public static LookupElementBuilder createPropertyLookupElement(
@NotNull String name, @Nullable PsiType type) {
LookupElementBuilder res =
LookupElementBuilder.create(name).withIcon(JetgroovyIcons.Groovy.Property);
if (type != null) {
res = res.withTypeText(type.getPresentableText());
}
return res;
}
@Override
public LookupElementBuilder createLookupBuilder(@NotNull VcsRef item) {
LookupElementBuilder lookupBuilder = super.createLookupBuilder(item);
if (myColorManager.isMultipleRoots()) {
lookupBuilder =
lookupBuilder.withTypeText(
getTypeText(item),
new ColorIcon(
15, VcsLogGraphTable.getRootBackgroundColor(item.getRoot(), myColorManager)),
true);
}
return lookupBuilder;
}
private void processProperty(
@NotNull PsiMethod method, @NotNull GroovyResolveResult resolveResult) {
if (myIsMap) return;
final LookupElementBuilder lookup =
createPropertyLookupElement(method, resolveResult, myMatcher);
if (lookup != null) {
if (myPropertyNames.add(lookup.getLookupString())) {
myConsumer.consume(lookup);
}
} else if (myEventListener != null) {
processListenerProperties(method);
}
}
@Override
protected void addCompletions(
@NotNull CompletionParameters completionParameters,
ProcessingContext processingContext,
@NotNull CompletionResultSet completionResultSet) {
YAMLKeyValue yamlKeyValue =
PsiTreeUtil.getParentOfType(
completionParameters.getOriginalPosition(), YAMLKeyValue.class);
if (yamlKeyValue != null) {
PsiElement compoundValue = yamlKeyValue.getParent();
if (compoundValue instanceof YAMLCompoundValue) {
// path and pattern are valid
String pattern =
YamlHelper.getYamlKeyValueAsString((YAMLCompoundValue) compoundValue, "path", false);
if (pattern == null) {
pattern =
YamlHelper.getYamlKeyValueAsString(
(YAMLCompoundValue) compoundValue, "pattern", false);
}
if (pattern != null) {
Matcher matcher = Pattern.compile("\\{(\\w+)}").matcher(pattern);
while (matcher.find()) {
completionResultSet.addElement(LookupElementBuilder.create(matcher.group(1)));
}
}
}
}
}
@Override
public LookupElement createLookupElement(String s) {
return LookupElementBuilder.create(s)
.withIcon(icons.MavenIcons.MavenPlugin)
.withTailText(
" (" + MavenRepositoriesProvider.getInstance().getRepositoryUrl(s) + ")", true);
}
private void processListenerProperties(@NotNull PsiMethod method) {
if (!method.getName().startsWith("add")
|| method.getParameterList().getParametersCount() != 1) return;
final PsiParameter parameter = method.getParameterList().getParameters()[0];
final PsiType type = parameter.getType();
if (!(type instanceof PsiClassType)) return;
final PsiClassType classType = (PsiClassType) type;
final PsiClass listenerClass = classType.resolve();
if (listenerClass == null) return;
final PsiMethod[] listenerMethods = listenerClass.getMethods();
if (!InheritanceUtil.isInheritorOrSelf(listenerClass, myEventListener, true)) return;
for (PsiMethod listenerMethod : listenerMethods) {
final String name = listenerMethod.getName();
if (myPropertyNames.add(name)) {
LookupElementBuilder builder =
LookupElementBuilder.create(
generatePropertyResolveResult(name, listenerMethod, null, null), name)
.withIcon(JetgroovyIcons.Groovy.Property);
myConsumer.consume(builder);
}
}
}
@Override
protected void addCompletions(
@NotNull CompletionParameters parameters,
ProcessingContext context,
@NotNull CompletionResultSet result) {
for (String[] completion :
RegExpLanguageHosts.getInstance().getPosixCharacterClasses(parameters.getPosition())) {
result.addElement(
LookupElementBuilder.create(completion[0])
.withTypeText((completion.length > 1) ? completion[1] : null)
.withIcon(emptyIcon)
.withInsertHandler(
new InsertHandler<LookupElement>() {
@Override
public void handleInsert(InsertionContext context, LookupElement item) {
context.setAddCompletionChar(false);
final Editor editor = context.getEditor();
final Document document = editor.getDocument();
final int tailOffset = context.getTailOffset();
if (document.getTextLength() < tailOffset + 2
|| !document
.getText(new TextRange(tailOffset, tailOffset + 2))
.equals(":]")) {
document.insertString(tailOffset, ":]");
}
editor.getCaretModel().moveCaretRelatively(2, 0, false, false, true);
}
}));
}
}
// Get closing tag
private LookupElementBuilder reuseClosingTag(String name) {
if (!CLOSING_LOOKUPS.containsKey(name)) {
CLOSING_LOOKUPS.put(name, LookupElementBuilder.create(name));
}
return CLOSING_LOOKUPS.get(name);
}
private void addLanguageKeyword(CompletionResultSet resultSet, String text) {
// TODO:: order most common used first
String keywords =
"|abs|accept|alarm|atan2|AUTOLOAD|BEGIN|bind|binmode|bless|break|caller|chdir|CHECK|chmod|chomp|chop|chown|chr|chroot|close|closedir|connect|cos|crypt|dbmclose|dbmopen|defined|delete|DESTROY|die|dump|each|END|endgrent|endhostent|endnetent|endprotoent|endpwent|endservent|eof|eval|exec|exists|exit|fcntl|fileno|flock|fork|format|formline|getc|getgrent|getgrgid|getgrnam|gethostbyaddr|gethostbyname|gethostent|getlogin|getnetbyaddr|getnetbyname|getnetent|getpeername|getpgrp|getppid|getpriority|getprotobyname|getprotobynumber|getprotoent|getpwent|getpwnam|getpwuid|getservbyname|getservbyport|getservent|getsockname|getsockopt|glob|gmtime|goto|grep|hex|index|INIT|int|ioctl|join|keys|kill|last|lc|each|lcfirst|setnetent|length|link|listen|local|localtime|log|lstat|map|mkdir|msgctl|msgget|msgrcv|msgsnd|next|not|oct|open|opendir|ord|our|pack|pipe|pop|pos|print|printf|prototype|push|quotemeta|rand|read|readdir|readline|readlink|readpipe|recv|redo|ref|rename|require|reset|return|reverse|rewinddir|rindex|rmdir|say|scalar|seek|seekdir|select|semctl|semget|semop|send|setgrent|sethostent|each|lcfirst|setnetent|setpgrp|setpriority|setprotoent|setpwent|setservent|setsockopt|shift|shmctl|shmget|shmread|shmwrite|shutdown|sin|sleep|socket|socketpair|sort|splice|split|sprintf|sqrt|srand|stat|state|study|substr|symlink|syscall|sysopen|sysread|sysseek|system|syswrite|tell|telldir|tie|tied|time|times|truncate|ucfirst|umask|undef|UNITCHECK|unlink|unpack|unshift|untie|use|utime|values|vec|wait|waitpid|wantarray|warn|write|each|lcfirst|setnetent|cmp|continue|CORE|else|elsif|exp|for|foreach|lock|package|unless|until|while|ARGV|ARGVOUT|STDERR|STDIN|STDOUT";
Matcher matcher = Utils.applyRegex("\\|(" + text + "[^\\|]+)", keywords);
while (matcher.find()) {
resultSet.addElement(LookupElementBuilder.create(matcher.group(1)));
}
}
@Nullable
public static LookupElementBuilder createPropertyLookupElement(
@NotNull PsiMethod accessor,
@Nullable GroovyResolveResult resolveResult,
@Nullable PrefixMatcher matcher) {
String propName;
PsiType propType;
final boolean getter = GroovyPropertyUtils.isSimplePropertyGetter(accessor, null);
if (getter) {
propName = GroovyPropertyUtils.getPropertyNameByGetter(accessor);
} else if (GroovyPropertyUtils.isSimplePropertySetter(accessor, null)) {
propName = GroovyPropertyUtils.getPropertyNameBySetter(accessor);
} else {
return null;
}
assert propName != null;
if (!PsiUtil.isValidReferenceName(propName)) {
propName = "'" + propName + "'";
}
if (matcher != null && !matcher.prefixMatches(propName)) {
return null;
}
if (getter) {
propType = PsiUtil.getSmartReturnType(accessor);
} else {
propType = accessor.getParameterList().getParameters()[0].getType();
}
final PsiType substituted =
resolveResult != null ? resolveResult.getSubstitutor().substitute(propType) : propType;
LookupElementBuilder builder =
LookupElementBuilder.create(
generatePropertyResolveResult(propName, accessor, propType, resolveResult),
propName)
.withIcon(JetgroovyIcons.Groovy.Property);
if (substituted != null) {
builder = builder.withTypeText(substituted.getPresentableText());
}
return builder;
}
@Override
public Object[] getCompletionVariants(
String completionPrefix, PsiElement location, ProcessingContext context) {
List<Object> result = new ArrayList<Object>();
Collections.addAll(result, super.getCompletionVariants(completionPrefix, location, context));
for (String field : myFields) {
result.add(LookupElementBuilder.create(field));
}
return ArrayUtil.toObjectArray(result);
}
@Override
public LookupElement[] calculateLookupItems(
@NotNull Expression[] params, ExpressionContext context) {
Object o = runIt(params, context);
if (o != null) {
Set<LookupElement> set = new LinkedHashSet<LookupElement>();
set.add(LookupElementBuilder.create(o.toString()));
return set.toArray(new LookupElement[set.size()]);
}
return LookupElement.EMPTY_ARRAY;
}
@Override
public LookupElement[] calculateLookupItems(
@NotNull Expression[] params, ExpressionContext context) {
PsiNamedElement[] vars = getSupertypes(params, context);
if (vars == null || vars.length < 2) return null;
Set<LookupElement> set = new LinkedHashSet<LookupElement>();
for (PsiNamedElement var : vars) {
set.add(LookupElementBuilder.create(var));
}
return set.toArray(new LookupElement[set.size()]);
}
@NotNull
@Override
public Object[] getVariants() {
List<LookupElement> lookupElements = new ArrayList<LookupElement>();
for (String variant : this.variants) {
lookupElements.add(LookupElementBuilder.create(variant));
}
return lookupElements.toArray();
}
private static LookupElement getSubLookupElementBuilder(Sub sub, boolean withArguments) {
String text =
(withArguments)
? sub.toString2(ConfigurationHolder.isHideFirstSelfArgument)
: sub.getName();
String containingPackage =
sub.getPackageObj().getQualifiedName() + "(" + sub.getPackageObj().getFileName() + ")";
return LookupElementBuilder.create(text)
.withIcon(PerlIcons.SUBROUTINE)
.withPresentableText(text)
.withTypeText(containingPackage, true);
}
public void testIdentifiersInPlainDocstring() {
final PyDocumentationSettings settings =
PyDocumentationSettings.getInstance(myFixture.getModule());
settings.setFormat(DocStringFormat.PLAIN);
myFixture.configureByFile("completion/identifiersInPlainDocstring.py");
final LookupElement[] elements = myFixture.completeBasic();
assertNotNull(elements);
assertContainsElements(
Lists.newArrayList(elements),
LookupElementBuilder.create("bar")
.withAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE));
}
@Override
public Object[] getVariants() {
ArrayList<LookupElementBuilder> _xblockexpression = null;
{
ProgressIndicatorProvider.checkCanceled();
ICrossReferenceDescription crossReferenceDescription = this.getCrossReferenceDescription();
boolean _equals = Objects.equal(crossReferenceDescription, null);
if (_equals) {
return ((Object[])
Conversions.unwrapArray(CollectionLiterals.<Object>emptyList(), Object.class));
}
ArrayList<LookupElementBuilder> variants =
CollectionLiterals.<LookupElementBuilder>newArrayList();
Iterable<IEObjectDescription> _variants = crossReferenceDescription.getVariants();
for (final IEObjectDescription objectDescription : _variants) {
{
ProgressIndicatorProvider.checkCanceled();
QualifiedName _name = objectDescription.getName();
String name = this.qualifiedNameConverter.toString(_name);
BaseXtextFile _xtextFile = this.myElement.getXtextFile();
XtextResource _resource = _xtextFile.getResource();
PsiElement element =
this.psiModelAssociations.getPsiElement(objectDescription, _resource);
boolean _notEquals = (!Objects.equal(element, null));
if (_notEquals) {
LookupElementBuilder _create = LookupElementBuilder.create(name);
PsiElement _navigationElement = element.getNavigationElement();
PsiFile _containingFile = _navigationElement.getContainingFile();
String _name_1 = _containingFile.getName();
LookupElementBuilder _withTypeText = _create.withTypeText(_name_1);
variants.add(_withTypeText);
}
}
}
_xblockexpression = variants;
}
return ((Object[]) Conversions.unwrapArray(_xblockexpression, Object.class));
}
@Override
public LookupElement[] calculateLookupItems(
@NotNull Expression[] params, ExpressionContext context) {
if (params.length == 0) return null;
Set<LookupElement> set = new LinkedHashSet<>();
for (Expression param : params) {
Result object = param.calculateResult(context);
if (object != null) {
set.add(LookupElementBuilder.create(object.toString()));
}
}
return set.toArray(new LookupElement[set.size()]);
}
@NotNull
@Override
public LookupElement[] getVariants() {
final PsiElement element = getElement();
if (!myStartTagFlag) {
return super.getVariants();
}
final XmlTag xmlTag = (XmlTag) element;
final List<XmlElementDescriptor> variants =
TagNameReference.<XmlElementDescriptor>getTagNameVariants(
xmlTag, Arrays.asList(xmlTag.knownNamespaces()), new ArrayList<String>(), Function.ID);
final List<LookupElement> elements = new ArrayList<LookupElement>(variants.size());
for (XmlElementDescriptor descriptor : variants) {
final String descriptorName = descriptor.getName(element);
if (descriptorName != null) {
LookupElementBuilder lookupElement =
LookupElementBuilder.create(descriptor, descriptorName);
elements.add(lookupElement.withInsertHandler(JavaFxTagInsertHandler.INSTANCE));
}
}
return elements.toArray(new LookupElement[elements.size()]);
}
private static LookupElementBuilder createGenerateMethodElement(
PsiMethod prototype,
PsiSubstitutor substitutor,
Icon icon,
String typeText,
InsertHandler<LookupElement> insertHandler) {
String methodName = prototype.getName();
String visibility = VisibilityUtil.getVisibilityModifier(prototype.getModifierList());
String modifiers = (visibility == PsiModifier.PACKAGE_LOCAL ? "" : visibility + " ");
PsiType type = substitutor.substitute(prototype.getReturnType());
String signature =
modifiers + (type == null ? "" : type.getPresentableText() + " ") + methodName;
String parameters =
PsiFormatUtil.formatMethod(
prototype, substitutor, PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_NAME);
String overrideSignature =
" @Override "
+ signature; // leading space to make it a middle match, under all annotation
// suggestions
LookupElementBuilder element =
LookupElementBuilder.create(prototype, signature)
.withLookupString(methodName)
.withLookupString(signature)
.withLookupString(overrideSignature)
.withInsertHandler(insertHandler)
.appendTailText(parameters, false)
.appendTailText(" {...}", true)
.withTypeText(typeText)
.withIcon(icon);
element.putUserData(GENERATE_ELEMENT, true);
return element;
}
private static void addCompletionElements(
CompletionResultSet result, final Consumer<Task> consumer, List<Task> items, int index) {
final AutoCompletionPolicy completionPolicy =
ApplicationManager.getApplication().isUnitTestMode()
? AutoCompletionPolicy.ALWAYS_AUTOCOMPLETE
: AutoCompletionPolicy.NEVER_AUTOCOMPLETE;
for (final Task task : items) {
LookupElementBuilder builder =
LookupElementBuilder.create(task, task.getId())
.setIcon(task.getIcon())
.addLookupString(task.getSummary())
.setTailText(" " + task.getSummary(), true)
.setInsertHandler(
new InsertHandler<LookupElement>() {
@Override
public void handleInsert(InsertionContext context, LookupElement item) {
Document document = context.getEditor().getDocument();
String s = task.getId() + ": " + task.getSummary();
document.replaceString(context.getStartOffset(), context.getTailOffset(), s);
context
.getEditor()
.getCaretModel()
.moveToOffset(context.getStartOffset() + s.length());
consumer.consume(task);
}
});
if (task.isClosed()) {
builder = builder.setStrikeout();
}
result.addElement(
PrioritizedLookupElement.withGrouping(
builder.withAutoCompletionPolicy(completionPolicy), index--));
}
}
public void doTest(CompletionType type, int time, @Nullable String completeItem) {
try {
configureByFileNoComplete(getBeforeFileName());
setType(type);
complete(time);
if (completeItem != null) {
selectItem(LookupElementBuilder.create(completeItem), '\t');
}
checkResultByFile(getAfterFileName());
} catch (Exception e) {
throw new AssertionError(e);
}
}
@NotNull
@Override
public Collection<LookupElement> getLookupElements(
@NotNull SourceContributorParameter parameter) {
String sourceParameter = parameter.getSourceParameter();
if (sourceParameter == null) {
return Collections.emptyList();
}
Collection<LookupElement> lookupElements = new ArrayList<LookupElement>();
for (PhpClass phpClass :
PhpIndex.getInstance(parameter.getProject()).getAllSubclasses(sourceParameter)) {
lookupElements.add(
LookupElementBuilder.create(phpClass.getPresentableFQN()).withIcon(phpClass.getIcon()));
}
return lookupElements;
}
@NotNull
public Object[] getVariants() {
final AntDomMacroDef parentMacrodef = getParentMacrodef();
if (parentMacrodef != null) {
final List variants = new ArrayList();
for (AntDomMacrodefAttribute attribute : parentMacrodef.getMacroAttributes()) {
final String attribName = attribute.getName().getStringValue();
if (attribName != null && attribName.length() > 0) {
final LookupElementBuilder builder = LookupElementBuilder.create(attribName);
final LookupElement element =
AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE.applyPolicy(builder);
variants.add(element);
}
}
return ContainerUtil.toArray(variants, new Object[variants.size()]);
}
return EMPTY_ARRAY;
}
private static LookupElement[] initLookupItems(
LinkedHashSet<String> names, PsiNamedElement elementToRename, final boolean shouldSelectAll) {
if (names == null) {
names = new LinkedHashSet<String>();
for (NameSuggestionProvider provider :
Extensions.getExtensions(NameSuggestionProvider.EP_NAME)) {
final SuggestedNameInfo suggestedNameInfo =
provider.getSuggestedNames(elementToRename, elementToRename, names);
if (suggestedNameInfo != null
&& provider instanceof PreferrableNameSuggestionProvider
&& !((PreferrableNameSuggestionProvider) provider).shouldCheckOthers()) {
break;
}
}
}
final LookupElement[] lookupElements = new LookupElement[names.size()];
final Iterator<String> iterator = names.iterator();
for (int i = 0; i < lookupElements.length; i++) {
final String suggestion = iterator.next();
lookupElements[i] =
LookupElementBuilder.create(suggestion)
.withInsertHandler(
new InsertHandler<LookupElement>() {
@Override
public void handleInsert(InsertionContext context, LookupElement item) {
if (shouldSelectAll) return;
final Editor topLevelEditor =
InjectedLanguageUtil.getTopLevelEditor(context.getEditor());
final TemplateState templateState =
TemplateManagerImpl.getTemplateState(topLevelEditor);
if (templateState != null) {
final TextRange range = templateState.getCurrentVariableRange();
if (range != null) {
topLevelEditor
.getDocument()
.replaceString(
range.getStartOffset(), range.getEndOffset(), suggestion);
}
}
}
});
}
return lookupElements;
}
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
final Editor editor =
PlatformDataKeys.EDITOR.getData(DataManager.getInstance().getDataContext());
assert editor != null;
final TextRange textRange = ((ProblemDescriptorImpl) descriptor).getTextRange();
editor.getSelectionModel().setSelection(textRange.getStartOffset(), textRange.getEndOffset());
final String word = editor.getSelectionModel().getSelectedText();
if (word == null || StringUtil.isEmptyOrSpaces(word)) {
return;
}
final List<LookupElement> items = new ArrayList<LookupElement>();
for (String variant : myUnboundParams) {
items.add(LookupElementBuilder.create(variant));
}
LookupManager.getInstance(project)
.showLookup(editor, items.toArray(new LookupElement[items.size()]));
}
public Object[] getCompletionVariants(
String completionPrefix, PsiElement location, ProcessingContext context) {
List<LookupElement> result = new ArrayList<LookupElement>();
ScopeOwner scopeOwner = ScopeUtil.getScopeOwner(location);
assert scopeOwner != null;
final List<PyImportElement> importTargets = PyModuleType.getVisibleImports(scopeOwner);
final int imported = myImportedModule.getImportedPrefix().getComponentCount();
for (PyImportElement importTarget : importTargets) {
final QualifiedName qName = importTarget.getImportedQName();
if (qName != null && qName.matchesPrefix(myImportedModule.getImportedPrefix())) {
final List<String> components = qName.getComponents();
if (components.size() > imported) {
String module = components.get(imported);
result.add(LookupElementBuilder.create(module));
}
}
}
return result.toArray(new Object[result.size()]);
}
public void addCompletions(
@NotNull final CompletionParameters parameters,
final ProcessingContext context,
@NotNull final CompletionResultSet result) {
PsiElement element = parameters.getPosition();
while (element != null && !(element instanceof CfmlAttributeImpl)) {
element = element.getParent();
}
if (element == null) {
return;
}
CfmlAttributeImpl attribute = (CfmlAttributeImpl) element;
String attributeName = attribute.getFirstChild().getText();
while (element != null && !(element instanceof CfmlTag)) {
element = element.getParent();
}
if (element == null) {
return;
}
CfmlTag tag = (CfmlTag) element;
String tagName = tag.getTagName();
String[] attributeValue =
CfmlUtil.getAttributeValues(tagName, attributeName, parameters.getPosition().getProject());
if ("type".equalsIgnoreCase(attributeName) && "cfargument".equalsIgnoreCase(tagName)
|| "returntype".equalsIgnoreCase(attributeName) && "cffunction".equalsIgnoreCase(tagName)) {
Object[] objects =
CfmlComponentReference.buildVariants(
attribute.getPureAttributeValue(),
element.getContainingFile(),
element.getProject(),
null,
true);
for (Object o : objects) {
result.addElement((LookupElement) o);
}
}
for (String s : attributeValue) {
result.addElement(LookupElementBuilder.create(s).withCaseSensitivity(false));
}
}