| /* |
| * Copyright 2000-2014 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * Created by IntelliJ IDEA. |
| * User: cdr |
| * Date: Sep 4, 2007 |
| * Time: 7:17:07 PM |
| */ |
| package com.intellij.psi.impl.source.tree.injected; |
| |
| import com.intellij.lang.ASTNode; |
| import com.intellij.lang.Language; |
| import com.intellij.lang.StdLanguages; |
| import com.intellij.lang.injection.ConcatenationAwareInjector; |
| import com.intellij.lang.injection.InjectedLanguageManager; |
| import com.intellij.lang.injection.MultiHostInjector; |
| import com.intellij.lang.injection.MultiHostRegistrar; |
| import com.intellij.openapi.Disposable; |
| import com.intellij.openapi.extensions.ExtensionPoint; |
| import com.intellij.openapi.extensions.Extensions; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.util.Disposer; |
| import com.intellij.openapi.util.ProperTextRange; |
| import com.intellij.openapi.util.TextRange; |
| import com.intellij.openapi.util.text.StringUtil; |
| import com.intellij.psi.*; |
| import com.intellij.psi.impl.source.tree.PsiCommentImpl; |
| import com.intellij.psi.util.PsiTreeUtil; |
| import com.intellij.psi.xml.*; |
| import com.intellij.util.ArrayUtil; |
| import org.jetbrains.annotations.NonNls; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.TestOnly; |
| |
| import java.util.Arrays; |
| import java.util.List; |
| |
| public class MyTestInjector { |
| private final PsiManager myPsiManager; |
| |
| @TestOnly |
| public MyTestInjector(PsiManager psiManager) { |
| myPsiManager = psiManager; |
| } |
| |
| public void injectAll(Disposable parent) { |
| injectVariousStuffEverywhere(parent, myPsiManager); |
| |
| Project project = myPsiManager.getProject(); |
| Language ql = Language.findLanguageByID("JPAQL"); |
| Language js = Language.findLanguageByID("JavaScript"); |
| registerForStringVarInitializer(parent, project, ql, "ql", null, null); |
| registerForStringVarInitializer(parent, project, ql, "qlPrefixed", "xxx", null); |
| registerForStringVarInitializer(parent, project, js, "js", null, null); |
| registerForStringVarInitializer(parent, project, js, "jsSeparated", " + ", " + 'separator'"); |
| registerForStringVarInitializer(parent, project, js, "jsBrokenPrefix", "xx ", ""); |
| |
| registerForStringVarInitializer(parent, project, Language.findLanguageByID("Oracle"), "oracle", null, null); |
| |
| registerForParameterValue(parent, project, Language.findLanguageByID("Groovy"), "groovy"); |
| } |
| |
| private static void registerForParameterValue(Disposable parent, final Project project, final Language language, final String paramName) { |
| if (language == null) return; |
| final ConcatenationAwareInjector injector = new ConcatenationAwareInjector() { |
| @Override |
| public void getLanguagesToInject(@NotNull MultiHostRegistrar injectionPlacesRegistrar, @NotNull PsiElement... operands) { |
| PsiElement operand = operands[0]; |
| if (!(operand instanceof PsiLiteralExpression)) return; |
| if (!(operand.getParent() instanceof PsiExpressionList)) return; |
| PsiExpressionList expressionList = (PsiExpressionList)operand.getParent(); |
| int i = ArrayUtil.indexOf(expressionList.getExpressions(), operand); |
| if (!(operand.getParent().getParent() instanceof PsiMethodCallExpression)) return; |
| PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)operand.getParent().getParent(); |
| PsiMethod method = methodCallExpression.resolveMethod(); |
| if (method == null) return; |
| PsiParameter[] parameters = method.getParameterList().getParameters(); |
| if (i>=parameters.length) return; |
| PsiParameter parameter = parameters[i]; |
| if (!paramName.equals(parameter.getName())) return; |
| TextRange textRange = textRangeToInject((PsiLanguageInjectionHost)operand); |
| injectionPlacesRegistrar.startInjecting(language) |
| .addPlace(null, null, (PsiLanguageInjectionHost)operand, textRange) |
| .doneInjecting(); |
| } |
| }; |
| JavaConcatenationInjectorManager.getInstance(project).registerConcatenationInjector(injector); |
| Disposer.register(parent, new Disposable() { |
| @Override |
| public void dispose() { |
| boolean b = JavaConcatenationInjectorManager.getInstance(project).unregisterConcatenationInjector(injector); |
| assert b; |
| } |
| }); |
| } |
| |
| private static void registerForStringVarInitializer(@NotNull Disposable parent, |
| @NotNull final Project project, |
| final Language language, |
| @NotNull @NonNls final String varName, |
| @NonNls final String prefix, |
| @NonNls final String suffix) { |
| if (language == null) return; |
| final ConcatenationAwareInjector injector = new ConcatenationAwareInjector() { |
| @Override |
| public void getLanguagesToInject(@NotNull MultiHostRegistrar injectionPlacesRegistrar, @NotNull PsiElement... operands) { |
| PsiVariable variable = PsiTreeUtil.getParentOfType(operands[0], PsiVariable.class); |
| if (variable == null) return; |
| if (!varName.equals(variable.getName())) return; |
| if (!(operands[0] instanceof PsiLiteralExpression)) return; |
| boolean started = false; |
| String prefixFromPrev=""; |
| for (int i = 0; i < operands.length; i++) { |
| PsiElement operand = operands[i]; |
| if (!(operand instanceof PsiLiteralExpression)) { |
| continue; |
| } |
| Object value = ((PsiLiteralExpression)operand).getValue(); |
| if (!(value instanceof String)) { |
| prefixFromPrev += value; |
| continue; |
| } |
| TextRange textRange = textRangeToInject((PsiLanguageInjectionHost)operand); |
| if (!started) { |
| injectionPlacesRegistrar.startInjecting(language); |
| started = true; |
| } |
| injectionPlacesRegistrar.addPlace(prefixFromPrev + (i == 0 ? "" : prefix==null?"":prefix), i == operands.length - 1 ? null : suffix, (PsiLanguageInjectionHost)operand, textRange); |
| prefixFromPrev = ""; |
| } |
| if (started) { |
| injectionPlacesRegistrar.doneInjecting(); |
| } |
| } |
| }; |
| JavaConcatenationInjectorManager.getInstance(project).registerConcatenationInjector(injector); |
| Disposer.register(parent, new Disposable() { |
| @Override |
| public void dispose() { |
| boolean b = JavaConcatenationInjectorManager.getInstance(project).unregisterConcatenationInjector(injector); |
| assert b; |
| } |
| }); |
| } |
| |
| private static void injectVariousStuffEverywhere(Disposable parent, final PsiManager psiManager) { |
| final Language ql = Language.findLanguageByID("JPAQL"); |
| final Language js = Language.findLanguageByID("JavaScript"); |
| final Language html = Language.findLanguageByID("HTML"); |
| if (ql == null || js == null) return; |
| final Language ecma4 = Language.findLanguageByID("ECMA Script Level 4"); |
| |
| final MultiHostInjector myMultiHostInjector = new MultiHostInjector() { |
| @Override |
| public void getLanguagesToInject(@NotNull MultiHostRegistrar registrar, @NotNull PsiElement context) { |
| XmlAttributeValue value = (XmlAttributeValue)context; |
| PsiElement parent = value.getParent(); |
| if (parent instanceof XmlAttribute) { |
| @NonNls String attrName = ((XmlAttribute)parent).getLocalName(); |
| if ("jsInBraces".equals(attrName)) { |
| registrar.startInjecting(js); |
| String text = value.getText(); |
| int index = 0; |
| while (text.indexOf('{', index) != -1) { |
| int lbrace = text.indexOf('{', index); |
| int rbrace = text.indexOf('}', index); |
| registrar.addPlace("", "", (PsiLanguageInjectionHost)value, new TextRange(lbrace + 1, rbrace)); |
| index = rbrace + 1; |
| } |
| registrar.doneInjecting(); |
| } |
| } |
| } |
| |
| @Override |
| @NotNull |
| public List<? extends Class<? extends PsiElement>> elementsToInjectIn() { |
| return Arrays.asList(XmlAttributeValue.class); |
| } |
| }; |
| InjectedLanguageManager.getInstance(psiManager.getProject()).registerMultiHostInjector(myMultiHostInjector); |
| Disposer.register(parent, new Disposable() { |
| @Override |
| public void dispose() { |
| boolean b = InjectedLanguageManager.getInstance(psiManager.getProject()).unregisterMultiHostInjector(myMultiHostInjector); |
| assert b; |
| } |
| }); |
| |
| final LanguageInjector myInjector = new LanguageInjector() { |
| @Override |
| public void getLanguagesToInject(@NotNull PsiLanguageInjectionHost host, @NotNull InjectedLanguagePlaces placesToInject) { |
| if (host instanceof XmlAttributeValue) { |
| XmlAttributeValue value = (XmlAttributeValue)host; |
| PsiElement parent = value.getParent(); |
| if (parent instanceof XmlAttribute) { |
| @NonNls String attrName = ((XmlAttribute)parent).getLocalName(); |
| if ("ql".equals(attrName)) { |
| inject(host, placesToInject, ql); |
| return; |
| } |
| if ("js".equals(attrName)) { |
| inject(host, placesToInject, js); |
| return; |
| } |
| |
| if ("jsprefix".equals(attrName)) { |
| inject(host, placesToInject, js, "function foo(doc, window){", "}"); |
| return; |
| } |
| } |
| } |
| if (host instanceof XmlText) { |
| // inject to xml tags named 'ql' |
| final XmlText xmlText = (XmlText)host; |
| XmlTag tag = xmlText.getParentTag(); |
| if (tag == null) return; |
| if ("ql".equals(tag.getLocalName())) { |
| inject(host, placesToInject, ql); |
| return; |
| } |
| if ("js".equals(tag.getLocalName())) { |
| inject(host, placesToInject, js); |
| return; |
| } |
| if ("htmlInject".equals(tag.getLocalName())) { |
| inject(host, placesToInject, html); |
| return; |
| } |
| if (ecma4 != null && "ecma4".equals(tag.getLocalName())) { |
| inject(host, placesToInject, ecma4); |
| return; |
| } |
| if ("jsprefix".equals(tag.getLocalName())) { |
| inject(host, placesToInject, js, "function foo(doc, window){", "}"); |
| return; |
| } |
| |
| if ("jsInHash".equals(tag.getLocalName())) { |
| String text = xmlText.getText(); |
| if (text.contains("#")) { |
| int start = text.indexOf('#'); |
| int end = text.lastIndexOf('#'); |
| if (start != end && start != -1) { |
| placesToInject.addPlace(js, new TextRange(start + 1, end), null, null); |
| return; |
| } |
| } |
| } |
| } |
| |
| if (host instanceof PsiComment && ((PsiComment)host).getTokenType() == JavaTokenType.C_STYLE_COMMENT) { |
| /* {{{ |
| * js code |
| * js code |
| * }}} |
| */ |
| String text = host.getText(); |
| String prefix = "/*\n * {{{\n"; |
| String suffix = " }}}\n */"; |
| if (text.startsWith(prefix) && text.endsWith(suffix)) { |
| String s = StringUtil.trimEnd(StringUtil.trimStart(text, prefix), suffix); |
| int off = 0; |
| while (!s.isEmpty()) { |
| String t = s.trim(); |
| if (t.startsWith("*")) t = t.substring(1).trim(); |
| int i = s.length() - t.length(); |
| off += i; |
| int endOfLine = t.indexOf('\n'); |
| if (endOfLine == -1) endOfLine = t.length(); |
| placesToInject.addPlace(js, TextRange.from(prefix.length() + off, endOfLine), "", "\n"); |
| off += endOfLine; |
| s = s.substring(i+endOfLine); |
| } |
| return; |
| } |
| } |
| |
| if (host instanceof PsiCommentImpl) { |
| String text = host.getText(); |
| if (text.startsWith("/*--{") && text.endsWith("}--*/")) { |
| TextRange textRange = new TextRange(4, text.length()-4); |
| if (!(host.getParent()instanceof PsiMethod)) return; |
| PsiMethod method = (PsiMethod)host.getParent(); |
| if (!method.hasModifierProperty(PsiModifier.NATIVE) || !method.hasModifierProperty(PsiModifier.PUBLIC)) return; |
| String paramList = ""; |
| for (PsiParameter parameter : method.getParameterList().getParameters()) { |
| if (!paramList.isEmpty()) paramList += ","; |
| paramList += parameter.getName(); |
| } |
| @NonNls String header = "function " + method.getName() + "("+paramList+") {"; |
| Language gwt = Language.findLanguageByID("GWT JavaScript"); |
| placesToInject.addPlace(gwt, textRange, header, "}"); |
| return; |
| } |
| PsiElement parent = host.getParent(); |
| if (parent instanceof PsiMethod && ((PsiMethod)parent).getName().equals("xml")) { |
| placesToInject.addPlace(StdLanguages.XML, new TextRange(2,host.getTextLength()-2), null,null); |
| return; |
| } |
| } |
| |
| // inject to all string literal initializers of variables named 'ql' |
| if (host instanceof PsiLiteralExpression && ((PsiLiteralExpression)host).getValue() instanceof String) { |
| PsiVariable variable = PsiTreeUtil.getParentOfType(host, PsiVariable.class); |
| if (variable == null) return; |
| if (host.getParent() instanceof PsiPolyadicExpression) return; |
| if ("ql".equals(variable.getName())) { |
| placesToInject.addPlace(ql, textRangeToInject(host), null, null); |
| } |
| if ("xml".equals(variable.getName())) { |
| placesToInject.addPlace(StdLanguages.XML, textRangeToInject(host), null, null); |
| } |
| if ("js".equals(variable.getName())) { // with prefix/suffix |
| placesToInject.addPlace(js, textRangeToInject(host), "function foo(doc,window) {", "}"); |
| } |
| |
| if ("lang".equals(variable.getName())) { |
| // various lang depending on field "languageID" content |
| PsiClass aClass = PsiTreeUtil.getParentOfType(variable, PsiClass.class); |
| aClass = aClass.findInnerClassByName("Language", false); |
| String text = aClass.getInitializers()[0].getBody().getFirstBodyElement().getNextSibling().getText().substring(2); |
| Language language = Language.findLanguageByID(text); |
| |
| if (language != null) { |
| placesToInject.addPlace(language, textRangeToInject(host), "", ""); |
| } |
| } |
| } |
| } |
| }; |
| |
| final ExtensionPoint<LanguageInjector> extensionPoint = Extensions.getRootArea().getExtensionPoint(LanguageInjector.EXTENSION_POINT_NAME); |
| extensionPoint.registerExtension(myInjector); |
| Disposer.register(parent, new Disposable() { |
| @Override |
| public void dispose() { |
| extensionPoint.unregisterExtension(myInjector); |
| } |
| }); |
| } |
| |
| private static void inject(final PsiLanguageInjectionHost host, final InjectedLanguagePlaces placesToInject, final Language language) { |
| inject(host, placesToInject, language, null, null); |
| } |
| private static void inject(final PsiLanguageInjectionHost host, final InjectedLanguagePlaces placesToInject, final Language language, @NonNls String prefix, String suffix) { |
| TextRange insideQuotes = textRangeToInject(host); |
| |
| placesToInject.addPlace(language, insideQuotes, prefix, suffix); |
| } |
| |
| public static TextRange textRangeToInject(PsiLanguageInjectionHost host) { |
| ASTNode[] children = ((ASTNode)host).getChildren(null); |
| TextRange insideQuotes = new ProperTextRange(0, host.getTextLength()); |
| |
| if (children.length > 1 && children[0].getElementType() == XmlTokenType.XML_ATTRIBUTE_VALUE_START_DELIMITER) { |
| insideQuotes = new ProperTextRange(children[1].getTextRange().getStartOffset() - host.getTextRange().getStartOffset(), insideQuotes.getEndOffset()); |
| } |
| if (children.length > 1 && children[children.length-1].getElementType() == XmlTokenType.XML_ATTRIBUTE_VALUE_END_DELIMITER) { |
| insideQuotes = new ProperTextRange(insideQuotes.getStartOffset(), children[children.length-2].getTextRange().getEndOffset() - host.getTextRange().getStartOffset()); |
| } |
| if (host instanceof PsiLiteralExpression) { |
| insideQuotes = new ProperTextRange(1, host.getTextLength()-1); |
| } |
| return insideQuotes; |
| } |
| } |
