public XmlAttributeDescriptor getAttributeDescriptor(String attributeName, final XmlTag context) {
String caseSensitiveAttributeName =
!myCaseSensitive ? attributeName.toLowerCase() : attributeName;
XmlAttributeDescriptor descriptor =
super.getAttributeDescriptor(caseSensitiveAttributeName, context);
if (descriptor == null)
descriptor =
RelaxedHtmlFromSchemaElementDescriptor.getAttributeDescriptorFromFacelets(
attributeName, context);
if (descriptor == null) {
String prefix = XmlUtil.findPrefixByQualifiedName(attributeName);
if ("xml"
.equals(
prefix)) { // todo this is not technically correct dtd document references namespaces
// but we should handle it at least for xml stuff
XmlNSDescriptor nsdescriptor = context.getNSDescriptor(XmlUtil.XML_NAMESPACE_URI, true);
if (nsdescriptor instanceof XmlNSDescriptorImpl) {
descriptor =
((XmlNSDescriptorImpl) nsdescriptor)
.getAttribute(
XmlUtil.findLocalNameByQualifiedName(caseSensitiveAttributeName),
XmlUtil.XML_NAMESPACE_URI,
context);
}
}
}
if (descriptor == null && HtmlUtil.isHtml5Context(context)) {
descriptor = myDelegate.getAttributeDescriptor(attributeName, context);
}
return descriptor;
}
@Override
public void update(@NotNull AnActionEvent e) {
Presentation presentation = e.getPresentation();
OpenInBrowserRequest result = BaseOpenInBrowserAction.doUpdate(e);
if (result == null) {
return;
}
String description = getTemplatePresentation().getDescription();
if (HtmlUtil.isHtmlFile(result.getFile())) {
description += " (hold Shift to open URL of local file)";
}
presentation.setText(getTemplatePresentation().getText());
presentation.setDescription(description);
WebBrowser browser = findUsingBrowser();
if (browser != null) {
presentation.setIcon(browser.getIcon());
}
if (ActionPlaces.isPopupPlace(e.getPlace())) {
presentation.setVisible(presentation.isEnabled());
}
}
protected void checkAttribute(
@NotNull final XmlAttribute attribute,
@NotNull final ProblemsHolder holder,
final boolean isOnTheFly) {
final XmlTag tag = attribute.getParent();
if (tag instanceof HtmlTag) {
XmlElementDescriptor elementDescriptor = tag.getDescriptor();
if (elementDescriptor == null || elementDescriptor instanceof AnyXmlElementDescriptor) {
return;
}
XmlAttributeDescriptor attributeDescriptor =
elementDescriptor.getAttributeDescriptor(attribute);
final String name = attribute.getName();
if (attributeDescriptor == null && !attribute.isNamespaceDeclaration()) {
if (!XmlUtil.attributeFromTemplateFramework(name, tag)
&& (!isCustomValuesEnabled() || !isCustomValue(name))) {
final ASTNode node = attribute.getNode();
assert node != null;
final PsiElement nameElement =
XmlChildRole.ATTRIBUTE_NAME_FINDER.findChild(node).getPsi();
boolean maySwitchToHtml5 =
HtmlUtil.isCustomHtml5Attribute(name) && !HtmlUtil.hasNonHtml5Doctype(tag);
LocalQuickFix[] quickfixes = new LocalQuickFix[maySwitchToHtml5 ? 3 : 2];
quickfixes[0] =
new AddCustomTagOrAttributeIntentionAction(
getShortName(), name, XmlEntitiesInspection.UNKNOWN_ATTRIBUTE);
quickfixes[1] = new RemoveAttributeIntentionAction(name);
if (maySwitchToHtml5) {
quickfixes[2] = new SwitchToHtml5WithHighPriorityAction();
}
holder.registerProblem(
nameElement,
XmlErrorMessages.message("attribute.is.not.allowed.here", name),
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
quickfixes);
}
}
}
}
@Override
public Charset extractCharsetFromFileContent(
@Nullable final Project project,
@Nullable final VirtualFile file,
@NotNull final CharSequence content) {
String name = XmlCharsetDetector.extractXmlEncodingFromProlog(content);
Charset charset = CharsetToolkit.forName(name);
if (charset != null) {
return charset;
}
return HtmlUtil.detectCharsetFromMetaTag(content);
}
@Override
public String getCharset(@NotNull final VirtualFile file, @NotNull final byte[] content) {
String charset = XmlCharsetDetector.extractXmlEncodingFromProlog(content);
if (charset != null) return charset;
@NonNls String strContent;
try {
strContent = new String(content, "ISO-8859-1");
} catch (UnsupportedEncodingException e) {
return null;
}
Charset c = HtmlUtil.detectCharsetFromMetaTag(strContent);
return c == null ? null : c.name();
}
public void annotate(final PsiElement psiElement, final AnnotationHolder holder) {
if (psiElement instanceof XmlToken) {
final PsiElement parent = psiElement.getParent();
if (parent instanceof XmlTag) {
final XmlTag tag = (XmlTag) parent;
final XmlToken start = XmlTagUtil.getStartTagNameElement(tag);
XmlToken endTagName = XmlTagUtil.getEndTagNameElement(tag);
if (endTagName != null
&& !(tag instanceof HtmlTag)
&& !tag.getName().equals(endTagName.getText())) {
registerProblem(holder, tag, start, endTagName);
} else if (endTagName == null
&& !(tag instanceof HtmlTag && HtmlUtil.isSingleHtmlTag(tag.getName()))) {
final PsiErrorElement errorElement =
PsiTreeUtil.getChildOfType(tag, PsiErrorElement.class);
endTagName = findEndTagName(errorElement);
if (endTagName != null) {
registerProblem(holder, tag, start, endTagName);
}
}
} else if (parent instanceof PsiErrorElement) {
if (XmlTokenType.XML_NAME == ((XmlToken) psiElement).getTokenType()) {
final PsiFile psiFile = psiElement.getContainingFile();
if (psiFile != null
&& (HTMLLanguage.INSTANCE == psiFile.getViewProvider().getBaseLanguage()
|| HTMLLanguage.INSTANCE == parent.getLanguage())) {
final String message =
XmlErrorMessages.message("xml.parsing.closing.tag.mathes.nothing");
if (message.equals(((PsiErrorElement) parent).getErrorDescription())) {
final Annotation annotation = holder.createWarningAnnotation(parent, message);
annotation.registerFix(new RemoveExtraClosingTagIntentionAction());
}
}
}
}
}
}
@Override
public boolean canSelect(SelectInContext context) {
Object selectorInFile = context.getSelectorInFile();
if (!(selectorInFile instanceof PsiElement)) {
return false;
}
PsiFile file = ((PsiElement) selectorInFile).getContainingFile();
if (file == null || file.getVirtualFile() == null) {
return false;
}
Pair<WebBrowserUrlProvider, Url> browserUrlProvider = WebBrowserServiceImpl.getProvider(file);
currentName = XmlBundle.message("browser.select.in.default.name");
if (browserUrlProvider == null) {
return HtmlUtil.isHtmlFile(file) && !(file.getVirtualFile() instanceof LightVirtualFile);
} else {
String customText = browserUrlProvider.first.getOpenInBrowserActionText(file);
if (customText != null) {
currentName = customText;
}
}
return true;
}
@Override
protected void checkTag(
@NotNull final XmlTag tag, @NotNull final ProblemsHolder holder, final boolean isOnTheFly) {
if (!(tag instanceof HtmlTag)
|| !XmlHighlightVisitor.shouldBeValidated(tag)
|| isInSpecialHtml5Namespace(tag)) {
return;
}
XmlElementDescriptor descriptorFromContext = XmlUtil.getDescriptorFromContext(tag);
PsiElement parent = tag.getParent();
XmlElementDescriptor parentDescriptor =
parent instanceof XmlTag ? ((XmlTag) parent).getDescriptor() : null;
XmlElementDescriptor ownDescriptor =
isAbstractDescriptor(descriptorFromContext) ? tag.getDescriptor() : descriptorFromContext;
if (isAbstractDescriptor(ownDescriptor)
|| (parentDescriptor instanceof HtmlElementDescriptorImpl
&& ownDescriptor instanceof HtmlElementDescriptorImpl
&& isAbstractDescriptor(descriptorFromContext))) {
final String name = tag.getName();
if (!isCustomValuesEnabled() || !isCustomValue(name)) {
final AddCustomTagOrAttributeIntentionAction action =
new AddCustomTagOrAttributeIntentionAction(
TAG_KEY, name, XmlEntitiesInspection.UNKNOWN_TAG);
// todo: support "element is not allowed" message for html5
// some tags in html5 cannot be found in xhtml5.xsd if they are located in incorrect
// context, so they get any-element descriptor (ex. "canvas: tag)
final String message =
isAbstractDescriptor(ownDescriptor)
? XmlErrorMessages.message("unknown.html.tag", name)
: XmlErrorMessages.message("element.is.not.allowed.here", name);
final PsiElement startTagName = XmlTagUtil.getStartTagNameElement(tag);
assert startTagName != null;
final PsiElement endTagName = XmlTagUtil.getEndTagNameElement(tag);
List<LocalQuickFix> quickfixes = new ArrayList<LocalQuickFix>();
quickfixes.add(action);
if (isOnTheFly) {
ContainerUtil.addIfNotNull(
CreateNSDeclarationIntentionFix.createFix(startTagName, ""), quickfixes);
}
if (HtmlUtil.isHtml5Tag(name) && !HtmlUtil.hasNonHtml5Doctype(tag)) {
quickfixes.add(new SwitchToHtml5WithHighPriorityAction());
}
ProblemHighlightType highlightType =
tag.getContainingFile().getContext() == null
? ProblemHighlightType.GENERIC_ERROR_OR_WARNING
: ProblemHighlightType.INFORMATION;
if (startTagName.getTextLength() > 0) {
holder.registerProblem(
startTagName,
message,
highlightType,
quickfixes.toArray(new LocalQuickFix[quickfixes.size()]));
}
if (endTagName != null) {
holder.registerProblem(
endTagName,
message,
highlightType,
quickfixes.toArray(new LocalQuickFix[quickfixes.size()]));
}
}
}
}
public Result beforeCharTyped(
final char c,
final Project project,
final Editor editor,
final PsiFile editedFile,
final FileType fileType) {
final XmlEditorOptions xmlEditorOptions = XmlEditorOptions.getInstance();
if (c == '>'
&& xmlEditorOptions != null
&& xmlEditorOptions.isAutomaticallyInsertClosingTag()
&& (editedFile.getLanguage() instanceof XMLLanguage
|| editedFile.getViewProvider().getBaseLanguage() instanceof XMLLanguage)) {
PsiDocumentManager.getInstance(project).commitAllDocuments();
PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
FileViewProvider provider = editedFile.getViewProvider();
int offset = editor.getCaretModel().getOffset();
PsiElement element, elementAtCaret = null;
if (offset < editor.getDocument().getTextLength()) {
elementAtCaret = element = provider.findElementAt(offset, XMLLanguage.class);
if (!(element instanceof PsiWhiteSpace)) {
boolean nonAcceptableDelimiter = true;
if (element instanceof XmlToken) {
IElementType tokenType = ((XmlToken) element).getTokenType();
if (tokenType == XmlTokenType.XML_START_TAG_START
|| tokenType == XmlTokenType.XML_END_TAG_START) {
if (offset > 0) {
PsiElement previousElement = provider.findElementAt(offset - 1, XMLLanguage.class);
if (previousElement instanceof XmlToken) {
tokenType = ((XmlToken) previousElement).getTokenType();
element = previousElement;
nonAcceptableDelimiter = false;
}
}
} else if (tokenType == XmlTokenType.XML_NAME) {
if (element.getNextSibling() instanceof PsiErrorElement) {
nonAcceptableDelimiter = false;
}
}
if (tokenType == XmlTokenType.XML_TAG_END
|| tokenType == XmlTokenType.XML_EMPTY_ELEMENT_END
&& element.getTextOffset() == offset - 1) {
editor.getCaretModel().moveToOffset(offset + 1);
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
return Result.STOP;
}
}
if (nonAcceptableDelimiter) return Result.CONTINUE;
} else {
// check if right after empty end
PsiElement previousElement = provider.findElementAt(offset - 1, XMLLanguage.class);
if (previousElement instanceof XmlToken) {
final IElementType tokenType = ((XmlToken) previousElement).getTokenType();
if (tokenType == XmlTokenType.XML_EMPTY_ELEMENT_END) {
return Result.STOP;
}
}
}
PsiElement parent = element.getParent();
if (parent instanceof XmlText) {
final String text = parent.getText();
// check /
final int index = offset - parent.getTextOffset() - 1;
if (index >= 0 && text.charAt(index) == '/') {
return Result.CONTINUE; // already seen /
}
element = parent.getPrevSibling();
} else if (parent instanceof XmlTag && !(element.getPrevSibling() instanceof XmlTag)) {
element = parent;
} else if (parent instanceof XmlAttributeValue) {
element = parent;
}
} else {
element =
provider.findElementAt(editor.getDocument().getTextLength() - 1, XMLLanguage.class);
if (element == null) return Result.CONTINUE;
element = element.getParent();
}
if (offset > 0 && offset <= editor.getDocument().getTextLength()) {
if (editor.getDocument().getCharsSequence().charAt(offset - 1)
== '/') { // Some languages (e.g. GSP) allow character '/' in tag name.
return Result.CONTINUE;
}
}
if (element instanceof XmlAttributeValue) {
element = element.getParent().getParent();
}
while (element instanceof PsiWhiteSpace) element = element.getPrevSibling();
if (element instanceof XmlDocument) { // hack for closing tags in RHTML
element = element.getLastChild();
}
if (element == null) return Result.CONTINUE;
if (!(element instanceof XmlTag)) {
if (element instanceof XmlTokenImpl
&& element.getPrevSibling() != null
&& element.getPrevSibling().getText().equals("<")) {
// tag is started and there is another text in the end
editor.getDocument().insertString(offset, "</" + element.getText() + ">");
}
return Result.CONTINUE;
}
XmlTag tag = (XmlTag) element;
if (XmlUtil.getTokenOfType(tag, XmlTokenType.XML_TAG_END) != null) return Result.CONTINUE;
if (XmlUtil.getTokenOfType(tag, XmlTokenType.XML_EMPTY_ELEMENT_END) != null)
return Result.CONTINUE;
final XmlToken startToken = XmlUtil.getTokenOfType(tag, XmlTokenType.XML_START_TAG_START);
if (startToken == null || !startToken.getText().equals("<")) return Result.CONTINUE;
String name = tag.getName();
if (elementAtCaret instanceof XmlToken
&& ((XmlToken) elementAtCaret).getTokenType() == XmlTokenType.XML_NAME) {
name = name.substring(0, offset - elementAtCaret.getTextOffset());
}
if (tag instanceof HtmlTag && HtmlUtil.isSingleHtmlTag(name)) return Result.CONTINUE;
if ("".equals(name)) return Result.CONTINUE;
int tagOffset = tag.getTextRange().getStartOffset();
final XmlToken nameToken = XmlUtil.getTokenOfType(tag, XmlTokenType.XML_NAME);
if (nameToken != null && nameToken.getTextRange().getStartOffset() > offset)
return Result.CONTINUE;
HighlighterIterator iterator = ((EditorEx) editor).getHighlighter().createIterator(tagOffset);
if (BraceMatchingUtil.matchBrace(
editor.getDocument().getCharsSequence(),
editedFile.getFileType(),
iterator,
true,
true)) {
PsiElement parent = tag.getParent();
boolean hasBalance = true;
while (parent instanceof XmlTag && name.equals(((XmlTag) parent).getName())) {
ASTNode astNode = XmlChildRole.CLOSING_TAG_NAME_FINDER.findChild(parent.getNode());
if (astNode == null) {
hasBalance = false;
break;
}
parent = parent.getParent();
}
if (hasBalance) {
hasBalance = false;
for (ASTNode node = parent.getNode().getLastChildNode();
node != null;
node = node.getTreePrev()) {
ASTNode leaf = node;
if (leaf.getElementType() == TokenType.ERROR_ELEMENT) {
ASTNode firstChild = leaf.getFirstChildNode();
if (firstChild != null) leaf = firstChild;
else {
PsiElement psiElement = PsiTreeUtil.nextLeaf(leaf.getPsi());
leaf = psiElement != null ? psiElement.getNode() : null;
}
if (leaf != null && leaf.getElementType() == TokenType.WHITE_SPACE) {
PsiElement psiElement = PsiTreeUtil.nextLeaf(leaf.getPsi());
if (psiElement != null) leaf = psiElement.getNode();
}
}
if (leaf != null && leaf.getElementType() == XmlTokenType.XML_END_TAG_START) {
ASTNode treeNext = leaf.getTreeNext();
IElementType treeNextType;
if (treeNext != null
&& ((treeNextType = treeNext.getElementType()) == XmlTokenType.XML_NAME
|| treeNextType == XmlTokenType.XML_TAG_NAME)) {
if (name.equals(treeNext.getText())) {
ASTNode parentEndName =
parent instanceof XmlTag
? XmlChildRole.CLOSING_TAG_NAME_FINDER.findChild(parent.getNode())
: null;
hasBalance =
!(parent instanceof XmlTag)
|| parentEndName != null && !parentEndName.getText().equals(name);
break;
}
}
}
}
}
if (hasBalance) return Result.CONTINUE;
}
TextRange cdataReformatRange = null;
final XmlElementDescriptor descriptor = tag.getDescriptor();
if (descriptor instanceof XmlElementDescriptorWithCDataContent) {
final XmlElementDescriptorWithCDataContent cDataContainer =
(XmlElementDescriptorWithCDataContent) descriptor;
if (cDataContainer.requiresCdataBracesInContext(tag)) {
int rangeStart = offset;
@NonNls final String cDataStart = "><![CDATA[";
final String inserted = cDataStart + "\n]]>";
editor.getDocument().insertString(offset, inserted);
final int newoffset = offset + cDataStart.length();
editor.getCaretModel().moveToOffset(newoffset);
offset += inserted.length();
cdataReformatRange = new TextRange(rangeStart, offset + 1);
}
}
editor.getDocument().insertString(offset, "</" + name + ">");
if (cdataReformatRange != null) {
PsiDocumentManager.getInstance(project).commitDocument(editor.getDocument());
try {
CodeStyleManager.getInstance(project)
.reformatText(
file, cdataReformatRange.getStartOffset(), cdataReformatRange.getEndOffset());
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
return cdataReformatRange != null ? Result.STOP : Result.CONTINUE;
}
return Result.CONTINUE;
}
private void checkAttribute(XmlAttribute attribute) {
XmlTag tag = attribute.getParent();
final String name = attribute.getName();
PsiElement prevLeaf = PsiTreeUtil.prevLeaf(attribute);
if (!(prevLeaf instanceof PsiWhiteSpace)) {
TextRange textRange = attribute.getTextRange();
addToResults(
HighlightInfo.createHighlightInfo(
tag instanceof HtmlTag ? HighlightInfoType.WARNING : HighlightInfoType.ERROR,
textRange.getStartOffset(),
textRange.getStartOffset(),
XmlErrorMessages.message("attribute.should.be.preceded.with.space")));
}
if (attribute.isNamespaceDeclaration()) {
checkReferences(attribute.getValueElement());
return;
}
final String namespace = attribute.getNamespace();
if (XmlUtil.XML_SCHEMA_INSTANCE_URI.equals(namespace)) {
checkReferences(attribute.getValueElement());
return;
}
XmlElementDescriptor elementDescriptor = tag.getDescriptor();
if (elementDescriptor == null
|| elementDescriptor instanceof AnyXmlElementDescriptor
|| ourDoJaxpTesting) {
return;
}
XmlAttributeDescriptor attributeDescriptor =
elementDescriptor.getAttributeDescriptor(attribute);
if (attributeDescriptor == null) {
if (!XmlUtil.attributeFromTemplateFramework(name, tag)) {
final String localizedMessage =
XmlErrorMessages.message("attribute.is.not.allowed.here", name);
final HighlightInfo highlightInfo =
reportAttributeProblem(tag, name, attribute, localizedMessage);
if (highlightInfo != null) {
final XmlFile xmlFile = (XmlFile) tag.getContainingFile();
if (xmlFile != null) {
XmlExtension.getExtension(xmlFile).createAddAttributeFix(attribute, highlightInfo);
}
}
}
} else {
checkDuplicateAttribute(tag, attribute);
if (tag instanceof HtmlTag
&& attribute.getValueElement() == null
&& !HtmlUtil.isSingleHtmlAttribute(name)) {
final String localizedMessage =
XmlErrorMessages.message("empty.attribute.is.not.allowed", name);
reportAttributeProblem(tag, name, attribute, localizedMessage);
}
// we skip resolve of attribute references since there is separate check when taking attribute
// descriptors
PsiReference[] attrRefs = attribute.getReferences();
doCheckRefs(attribute, attrRefs, attribute.getNamespacePrefix().length() > 0 ? 2 : 1);
}
}
public XmlElementDescriptor[] getElementsDescriptors(final XmlTag context) {
return ArrayUtil.mergeArrays(
myDelegate.getElementsDescriptors(context), HtmlUtil.getCustomTagDescriptors(context));
}