com.intellij.psi.xml.XmlText Java Examples

private @NotNull
String extractDocumentation(XmlTag attributeTag) {
    StringBuilder attributeDocumentation = new StringBuilder();

    XmlTag attributeAnnotation = attributeTag.findFirstSubTag("xsd:annotation");
    if (attributeAnnotation != null) {
        XmlTag attributeDoc = attributeAnnotation.findFirstSubTag("xsd:documentation");
        if (attributeDoc != null) {
            for (XmlText textElement : attributeDoc.getValue().getTextElements()) {
                attributeDocumentation.append(textElement.getValue());
            }
        }
    }

    return attributeDocumentation.toString();
}
 

@Override
public Optional<String> extractTextFromElement(PsiElement element, boolean concatString, boolean stripWhitespace) {
    // maybe its xml then try that
    if (element instanceof XmlAttributeValue) {
        return Optional.ofNullable(((XmlAttributeValue) element).getValue());
    } else if (element instanceof XmlText) {
        return Optional.ofNullable(((XmlText) element).getValue());
    } else if (element instanceof XmlToken) {
        // it may be a token which is a part of an combined attribute
        if (concatString) {
            XmlAttributeValue xml = PsiTreeUtil.getParentOfType(element, XmlAttributeValue.class);
            if (xml != null) {
                return Optional.ofNullable(getInnerText(xml.getValue()));
            }
        } else {
            String returnText = element.getText();
            final PsiElement prevSibling = element.getPrevSibling();
            if (prevSibling != null && prevSibling.getText().equalsIgnoreCase("&amp;")) {
                returnText = prevSibling.getText() + returnText;
            }
            return Optional.ofNullable(getInnerText(returnText));
        }
    }
    return Optional.empty();
}
 

@NotNull
private Collection<PsiElement> getControllerActionElements(@NotNull XmlText xmlText) {
    PsiElement xmlTag = xmlText.getParent();
    if(!(xmlTag instanceof XmlTag)) {
        return Collections.emptyList();
    }

    String controllerName = ShopwareXmlCompletion.getControllerOnScope((XmlTag) xmlTag);
    if (controllerName == null) {
        return Collections.emptyList();
    }

    String value = xmlText.getValue();

    Collection<PsiElement> targets = new HashSet<>();

    ShopwareUtil.collectControllerAction(xmlText.getProject(), controllerName, (method, methodStripped, moduleName, controllerName1) -> {
        if(value.equalsIgnoreCase(methodStripped)) {
            targets.add(method);
        }
    }, "Backend");

    return targets;
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean b) {
    PsiElement element = getElement();
    PsiElement parent = element.getParent();

    String text = null;
    if(parent instanceof XmlText) {
        // <route><default key="_controller">Fo<caret>o\Bar</default></route>
        text = parent.getText();
    } else if(parent instanceof XmlAttribute) {
        // <route controller=""/>
        text = ((XmlAttribute) parent).getValue();
    }

    if(text == null || StringUtils.isBlank(text)) {
        return new ResolveResult[0];
    }

    return PsiElementResolveResult.createResults(
        RouteHelper.getMethodsOnControllerShortcut(getElement().getProject(), text)
    );
}
 

public static List<PsiElement> findXmlTexts(PsiElement[] psiElements) {
    List<PsiElement> xmlTexts = new ArrayList<>();
    for (PsiElement psiElement : psiElements) {
        if (psiElement instanceof XmlText) {
            xmlTexts.add(psiElement);
        }
    }
    return xmlTexts;
}
 

public boolean isInContext(@NotNull final PsiFile file, final int offset)
{
  if (!MuleConfigUtils.isMuleFile(file))
  {
      return false;
  }
  PsiElement element = file.findElementAt(offset);
  return element != null && PsiTreeUtil.getParentOfType(element, XmlText.class) != null;
}
 

@Override
public void getLanguagesToInject(@NotNull PsiLanguageInjectionHost host,
                                 @NotNull InjectedLanguagePlaces injectedLanguagePlaces) {
    if (MuleConfigUtils.isMuleFile(host.getContainingFile())) {
        if (host instanceof XmlAttributeValue) {
            // Try to inject a language, somewhat abusing the lazy evaluation of predicates :(
            for (Pair<String, String> language : languages) {
                if (tryInjectLanguage(language.getFirst(), language.getSecond(), host, injectedLanguagePlaces)) {
                    break;
                }
            }
        } else if (host instanceof XmlText) {
            final XmlTag tag = ((XmlText) host).getParentTag();
            if (tag != null) {
                final QName tagName = MuleConfigUtils.getQName(tag);
                if (tagName.equals(globalFunctions) || tagName.equals(expressionComponent) || tagName.equals(expressionTransformer)) {
                    final String scriptingName = MelLanguage.MEL_LANGUAGE_ID;
                    injectLanguage(host, injectedLanguagePlaces, scriptingName);
                } else if (tagName.equals(scriptingScript)) {
                    final String engine = tag.getAttributeValue("engine");
                    if (engine != null) {
                        injectLanguage(host, injectedLanguagePlaces, StringUtil.capitalize(engine));
                    }
                } else if (tagName.equals(dwSetPayload) || tagName.equals(dwSetProperty) || tagName.equals(dwSetVariable) || tagName.equals(dwSetSessionVar)) {
                    injectLanguage(host, injectedLanguagePlaces, WEAVE_LANGUAGE_ID);
                }
            }
        }
    }
}
 

private boolean available(PsiElement element) {
    PsiElement context = element.getContext();
    return context instanceof JSBlockStatement
            || context instanceof CssDeclaration
            || context instanceof XmlAttributeValue
            || context instanceof XmlText;
}
 

@Nullable
public static String getTextValueForElement(@NotNull PsiElement psiElement) {
    PsiElement parent = psiElement.getParent();

    String value = null;
    if(parent instanceof StringLiteralExpression) {
        value = ((StringLiteralExpression) parent).getContents();
    } else if(parent instanceof XmlAttributeValue) {
        // <foo attr="FOO"/>
        value = ((XmlAttributeValue) parent).getValue();
    } else if(parent instanceof XmlText) {
        // <foo>FOO</foo>
        value = ((XmlText) parent).getValue();
    } else if(parent instanceof YAMLScalar) {
        // foo: foo, foo: 'foo', foo: "foo"
        value = ((YAMLScalar) parent).getTextValue();
    } else if(psiElement.getNode().getElementType() == TwigTokenTypes.STRING_TEXT) {
        // twig: 'foobar'
        value = psiElement.getText();
    }

    if(StringUtils.isBlank(value)) {
        return null;
    }

    return value;
}
 

private void xmlVisitor(@NotNull ProblemsHolder holder, @NotNull PsiFile psiFile) {
    psiFile.acceptChildren(new PsiRecursiveElementVisitor() {
        @Override
        public void visitElement(PsiElement psiElement) {
            if(!XmlHelper.getArgumentValueWithTypePattern("constant").accepts(psiElement)) {
                super.visitElement(psiElement);
                return;
            }

            PsiElement xmlText = psiElement.getParent();
            if(!(xmlText instanceof XmlText)) {
                super.visitElement(psiElement);
                return;
            }

            String value = ((XmlText) xmlText).getValue();
            if(StringUtils.isBlank(value)) {
                super.visitElement(psiElement);
                return;
            }

            if(ServiceContainerUtil.getTargetsForConstant(xmlText.getProject(), value).size() == 0) {
                holder.registerProblem(xmlText, MESSAGE, ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
            }

            super.visitElement(psiElement);
        }
    });
}
 

/**
 * <foo>bar</foo>
 */
public static PsiElementPattern.Capture<PsiElement> getTagTextPattern(@NotNull String... tag) {
    return XmlPatterns
        .psiElement().withParent(
            PlatformPatterns.psiElement(XmlText.class).withParent(
                PlatformPatterns.psiElement(HtmlTag.class).withName(tag)
            )
        )
        .inFile(XmlPatterns.psiFile()
            .withName(XmlPatterns
                .string().endsWith(".twig")
            )
        );
}
 

public ParameterXmlReference(@NotNull XmlText element) {
    super(element);
    parameterName = element.getValue();
}
 

ConstantXmlReference(@NotNull XmlText element) {
    super(element);
}