| /* |
| * 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. |
| */ |
| package com.intellij.psi.formatter.xml; |
| |
| import com.intellij.formatting.*; |
| import com.intellij.lang.*; |
| import com.intellij.lang.xml.XMLLanguage; |
| import com.intellij.openapi.diagnostic.Logger; |
| import com.intellij.openapi.fileTypes.StdFileTypes; |
| import com.intellij.openapi.util.TextRange; |
| import com.intellij.psi.*; |
| import com.intellij.psi.codeStyle.CommonCodeStyleSettings; |
| import com.intellij.psi.formatter.WhiteSpaceFormattingStrategy; |
| import com.intellij.psi.formatter.WhiteSpaceFormattingStrategyFactory; |
| import com.intellij.psi.formatter.common.AbstractBlock; |
| import com.intellij.psi.impl.source.SourceTreeToPsiMap; |
| import com.intellij.psi.impl.source.tree.LeafElement; |
| import com.intellij.psi.impl.source.tree.TreeElement; |
| import com.intellij.psi.impl.source.tree.TreeUtil; |
| import com.intellij.psi.search.PsiElementProcessor; |
| import com.intellij.psi.templateLanguages.TemplateLanguageFileViewProvider; |
| import com.intellij.psi.tree.IElementType; |
| import com.intellij.psi.tree.TokenSet; |
| import com.intellij.psi.xml.*; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| |
| public abstract class AbstractXmlBlock extends AbstractBlock { |
| protected XmlFormattingPolicy myXmlFormattingPolicy; |
| protected final XmlInjectedLanguageBlockBuilder myInjectedBlockBuilder; |
| private final boolean myPreserveSpace; |
| |
| protected AbstractXmlBlock(final ASTNode node, |
| final Wrap wrap, |
| final Alignment alignment, |
| final XmlFormattingPolicy policy) { |
| this(node, wrap, alignment, policy, false); |
| } |
| |
| |
| protected AbstractXmlBlock(final ASTNode node, |
| final Wrap wrap, |
| final Alignment alignment, |
| final XmlFormattingPolicy policy, |
| final boolean preserveSpace) { |
| super(node, wrap, alignment); |
| myXmlFormattingPolicy = policy; |
| if (node.getTreeParent() == null) { |
| myXmlFormattingPolicy.setRootBlock(node, this); |
| } |
| myInjectedBlockBuilder = new XmlInjectedLanguageBlockBuilder(myXmlFormattingPolicy); |
| myPreserveSpace = shouldPreserveSpace(node, preserveSpace); |
| } |
| |
| |
| /** |
| * Handles xml:space='preserve|default' attribute. |
| * See <a href="http://www.w3.org/TR/2004/REC-xml-20040204/#sec-white-space">Extensible Markup Language (XML) 1.0 (Third Edition), |
| * White Space Handling</a> |
| * |
| * @return True if the space must be preserved (xml:space='preserve'), false if the attribute |
| * contains 'default'. If the attribute is not defined, return the current value. |
| */ |
| private static boolean shouldPreserveSpace(ASTNode node, boolean defaultValue) { |
| if (node.getPsi() instanceof XmlTag) { |
| XmlTag tag = (XmlTag)node.getPsi(); |
| if (tag != null) { |
| XmlAttribute spaceAttr = tag.getAttribute("xml:space"); |
| if (spaceAttr != null) { |
| String value = spaceAttr.getValue(); |
| if ("preserve".equals(value)) { |
| return true; |
| } |
| if ("default".equals(value)) { |
| return false; |
| } |
| } |
| } |
| } |
| return defaultValue; |
| } |
| |
| public boolean isPreserveSpace() { |
| return myPreserveSpace; |
| } |
| |
| |
| public static WrapType getWrapType(final int type) { |
| if (type == CommonCodeStyleSettings.DO_NOT_WRAP) return WrapType.NONE; |
| if (type == CommonCodeStyleSettings.WRAP_ALWAYS) return WrapType.ALWAYS; |
| if (type == CommonCodeStyleSettings.WRAP_AS_NEEDED) return WrapType.NORMAL; |
| return WrapType.CHOP_DOWN_IF_LONG; |
| } |
| |
| protected Alignment chooseAlignment(final ASTNode child, final Alignment attrAlignment, final Alignment textAlignment) { |
| if (myNode.getElementType() == XmlElementType.XML_TEXT) return getAlignment(); |
| final IElementType elementType = child.getElementType(); |
| if (elementType == XmlElementType.XML_ATTRIBUTE && myXmlFormattingPolicy.getShouldAlignAttributes()) return attrAlignment; |
| if (elementType == XmlElementType.XML_TEXT && myXmlFormattingPolicy.getShouldAlignText()) return textAlignment; |
| return null; |
| } |
| |
| private Wrap getTagEndWrapping(final XmlTag parent) { |
| return Wrap.createWrap(myXmlFormattingPolicy.getWrappingTypeForTagEnd(parent), true); |
| } |
| |
| protected Wrap chooseWrap(final ASTNode child, final Wrap tagBeginWrap, final Wrap attrWrap, final Wrap textWrap) { |
| if (myNode.getElementType() == XmlElementType.XML_TEXT) return textWrap; |
| final IElementType elementType = child.getElementType(); |
| if (elementType == XmlElementType.XML_ATTRIBUTE) return attrWrap; |
| if (elementType == XmlTokenType.XML_START_TAG_START) return tagBeginWrap; |
| if (elementType == XmlTokenType.XML_END_TAG_START) { |
| final PsiElement parent = SourceTreeToPsiMap.treeElementToPsi(child.getTreeParent()); |
| if (parent instanceof XmlTag) { |
| final XmlTag tag = (XmlTag)parent; |
| if (canWrapTagEnd(tag)) { |
| return getTagEndWrapping(tag); |
| } |
| } |
| return null; |
| } |
| if (elementType == XmlElementType.XML_TEXT || elementType == XmlTokenType.XML_DATA_CHARACTERS) return textWrap; |
| return null; |
| } |
| |
| protected boolean canWrapTagEnd(final XmlTag tag) { |
| return tag.getSubTags().length > 0; |
| } |
| |
| protected XmlTag getTag() { |
| return getTag(myNode); |
| } |
| |
| protected static XmlTag getTag(final ASTNode node) { |
| final PsiElement element = SourceTreeToPsiMap.treeElementToPsi(node); |
| if (element instanceof XmlTag) { |
| return (XmlTag)element; |
| } |
| else { |
| return null; |
| } |
| } |
| |
| protected Wrap createTagBeginWrapping(final XmlTag tag) { |
| return Wrap.createWrap(myXmlFormattingPolicy.getWrappingTypeForTagBegin(tag), true); |
| } |
| |
| @Nullable |
| protected |
| ASTNode processChild(List<Block> result, |
| final ASTNode child, |
| final Wrap wrap, |
| final Alignment alignment, |
| final Indent indent) { |
| final Language myLanguage = myNode.getPsi().getLanguage(); |
| final PsiElement childPsi = child.getPsi(); |
| final Language childLanguage = childPsi.getLanguage(); |
| if (useMyFormatter(myLanguage, childLanguage, childPsi)) { |
| |
| XmlTag tag = getAnotherTreeTag(child); |
| if (tag != null |
| && containsTag(tag) |
| && doesNotIntersectSubTagsWith(tag)) { |
| ASTNode currentChild = createAnotherTreeNode(result, child, tag, indent, wrap, alignment); |
| |
| if (currentChild == null) { |
| return null; |
| } |
| |
| while (currentChild != null && currentChild.getTreeParent() != myNode && currentChild.getTreeParent() != child.getTreeParent()) { |
| currentChild = processAllChildrenFrom(result, currentChild, wrap, alignment, indent); |
| if (currentChild != null && (currentChild.getTreeParent() == myNode || currentChild.getTreeParent() == child.getTreeParent())) { |
| return currentChild; |
| } |
| if (currentChild != null) { |
| currentChild = currentChild.getTreeParent(); |
| |
| } |
| } |
| |
| return currentChild; |
| } |
| |
| processSimpleChild(child, indent, result, wrap, alignment); |
| return child; |
| } |
| else { |
| myInjectedBlockBuilder.addInjectedLanguageBlockWrapper(result, child, indent, 0, null); |
| return child; |
| } |
| } |
| |
| protected boolean doesNotIntersectSubTagsWith(final PsiElement tag) { |
| final TextRange tagRange = tag.getTextRange(); |
| final XmlTag[] subTags = getSubTags(); |
| for (XmlTag subTag : subTags) { |
| final TextRange subTagRange = subTag.getTextRange(); |
| if (subTagRange.getEndOffset() < tagRange.getStartOffset()) continue; |
| if (subTagRange.getStartOffset() > tagRange.getEndOffset()) return true; |
| |
| if (tagRange.getStartOffset() > subTagRange.getStartOffset() && tagRange.getEndOffset() < subTagRange.getEndOffset()) return false; |
| if (tagRange.getEndOffset() > subTagRange.getStartOffset() && tagRange.getEndOffset() < subTagRange.getEndOffset()) return false; |
| |
| } |
| return true; |
| } |
| |
| private XmlTag[] getSubTags() { |
| |
| if (myNode instanceof XmlTag) { |
| return ((XmlTag)myNode.getPsi()).getSubTags(); |
| } |
| else if (myNode.getPsi() instanceof XmlElement) { |
| return collectSubTags((XmlElement)myNode.getPsi()); |
| } |
| else { |
| return new XmlTag[0]; |
| } |
| |
| } |
| |
| private static XmlTag[] collectSubTags(final XmlElement node) { |
| final List<XmlTag> result = new ArrayList<XmlTag>(); |
| node.processElements(new PsiElementProcessor() { |
| @Override |
| public boolean execute(@NotNull final PsiElement element) { |
| if (element instanceof XmlTag) { |
| result.add((XmlTag)element); |
| } |
| return true; |
| } |
| }, node); |
| return result.toArray(new XmlTag[result.size()]); |
| } |
| |
| protected boolean containsTag(final PsiElement tag) { |
| final ASTNode closingTagStart = XmlChildRole.CLOSING_TAG_START_FINDER.findChild(myNode); |
| final ASTNode startTagStart = XmlChildRole.START_TAG_END_FINDER.findChild(myNode); |
| |
| if (closingTagStart == null && startTagStart == null) { |
| return tag.getTextRange().getEndOffset() <= myNode.getTextRange().getEndOffset(); |
| } |
| else if (closingTagStart == null) { |
| return false; |
| } |
| else { |
| return tag.getTextRange().getEndOffset() <= closingTagStart.getTextRange().getEndOffset(); |
| } |
| } |
| |
| private ASTNode processAllChildrenFrom(final List<Block> result, |
| @NotNull final ASTNode child, |
| final Wrap wrap, |
| final Alignment alignment, |
| final Indent indent) { |
| ASTNode resultNode = child; |
| ASTNode currentChild = child.getTreeNext(); |
| while (currentChild != null && currentChild.getElementType() != XmlTokenType.XML_END_TAG_START) { |
| if (!containsWhiteSpacesOnly(currentChild)) { |
| currentChild = processChild(result, currentChild, wrap, alignment, indent); |
| resultNode = currentChild; |
| } |
| if (currentChild != null) { |
| currentChild = currentChild.getTreeNext(); |
| } |
| } |
| return resultNode; |
| } |
| |
| protected void processSimpleChild(final ASTNode child, |
| final Indent indent, |
| final List<Block> result, |
| final Wrap wrap, |
| final Alignment alignment) { |
| if (isXmlTag(child)) { |
| result.add(createTagBlock(child, indent != null ? indent : Indent.getNoneIndent(), wrap, alignment)); |
| } else if (child.getElementType() == XmlElementType.XML_DOCTYPE) { |
| result.add( |
| new XmlBlock(child, wrap, alignment, myXmlFormattingPolicy, indent, null, isPreserveSpace()) { |
| @Override |
| protected Wrap getDefaultWrap(final ASTNode node) { |
| final IElementType type = node.getElementType(); |
| return type == XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN |
| ? Wrap.createWrap(getWrapType(myXmlFormattingPolicy.getAttributesWrap()), false) : null; |
| } |
| } |
| ); |
| } |
| else { |
| result.add(createSimpleChild(child, indent, wrap, alignment)); |
| } |
| } |
| |
| |
| protected XmlBlock createSimpleChild(final ASTNode child, final Indent indent, final Wrap wrap, final Alignment alignment) { |
| return new XmlBlock(child, wrap, alignment, myXmlFormattingPolicy, indent, null, isPreserveSpace()); |
| } |
| |
| protected XmlTagBlock createTagBlock(final ASTNode child, final Indent indent, final Wrap wrap, final Alignment alignment) { |
| return new XmlTagBlock(child, wrap, alignment, myXmlFormattingPolicy, indent != null ? indent : Indent.getNoneIndent(), isPreserveSpace()); |
| } |
| |
| @Nullable |
| protected XmlTag findXmlTagAt(final ASTNode child, final int startOffset) { |
| return null; |
| } |
| |
| @Nullable |
| protected ASTNode createAnotherTreeNode(final List<Block> result, |
| final ASTNode child, |
| PsiElement tag, |
| final Indent indent, |
| final Wrap wrap, final Alignment alignment) { |
| return null; |
| } |
| |
| @Nullable |
| protected Block createAnotherTreeTagBlock(final PsiElement tag, final Indent childIndent) { |
| return null; |
| } |
| |
| protected XmlFormattingPolicy createPolicyFor() { |
| return myXmlFormattingPolicy; |
| } |
| |
| @Nullable |
| protected XmlTag getAnotherTreeTag(final ASTNode child) { |
| return null; |
| |
| } |
| protected boolean isXmlTag(final ASTNode child) { |
| return isXmlTag(child.getPsi()); |
| } |
| |
| protected boolean isXmlTag(final PsiElement psi) { |
| return psi instanceof XmlTag; |
| } |
| |
| protected boolean useMyFormatter(final Language myLanguage, final Language childLanguage, final PsiElement childPsi) { |
| if (myLanguage == childLanguage || |
| childLanguage == StdFileTypes.HTML.getLanguage() || |
| childLanguage == StdFileTypes.XHTML.getLanguage() || |
| childLanguage == StdFileTypes.XML.getLanguage()) { |
| return true; |
| } |
| final FormattingModelBuilder childFormatter = LanguageFormatting.INSTANCE.forLanguage(childLanguage); |
| return childFormatter == null || |
| childFormatter instanceof DelegatingFormattingModelBuilder && |
| ((DelegatingFormattingModelBuilder)childFormatter).dontFormatMyModel(); |
| } |
| |
| protected boolean isJspxJavaContainingNode(final ASTNode child) { |
| return false; |
| } |
| |
| public abstract boolean insertLineBreakBeforeTag(); |
| |
| public abstract boolean removeLineBreakBeforeTag(); |
| |
| protected Spacing createDefaultSpace(boolean forceKeepLineBreaks, final boolean inText) { |
| boolean shouldKeepLineBreaks = getShouldKeepLineBreaks(inText, forceKeepLineBreaks); |
| return Spacing.createSpacing(0, Integer.MAX_VALUE, 0, shouldKeepLineBreaks, myXmlFormattingPolicy.getKeepBlankLines()); |
| } |
| |
| private boolean getShouldKeepLineBreaks(final boolean inText, final boolean forceKeepLineBreaks) { |
| if (forceKeepLineBreaks) { |
| return true; |
| } |
| if (inText && myXmlFormattingPolicy.getShouldKeepLineBreaksInText()) { |
| return true; |
| } |
| if (!inText && myXmlFormattingPolicy.getShouldKeepLineBreaks()) { |
| return true; |
| } |
| return false; |
| } |
| |
| public abstract boolean isTextElement(); |
| |
| private static final Logger LOG = Logger.getInstance("#com.intellij.psi.formatter.xml.AbstractXmlBlock"); |
| |
| protected void createJspTextNode(final List<Block> localResult, final ASTNode child, final Indent indent) { |
| } |
| |
| @Nullable |
| protected static ASTNode findChildAfter(@NotNull final ASTNode child, final int endOffset) { |
| TreeElement fileNode = TreeUtil.getFileElement((TreeElement)child); |
| final LeafElement leaf = fileNode.findLeafElementAt(endOffset); |
| if (leaf != null && leaf.getStartOffset() == endOffset && endOffset > 0) { |
| return fileNode.findLeafElementAt(endOffset - 1); |
| } |
| return leaf; |
| } |
| |
| @Override |
| public boolean isLeaf() { |
| return (isComment(myNode)) || |
| myNode.getElementType() == TokenType.WHITE_SPACE || |
| myNode.getElementType() == XmlTokenType.XML_DATA_CHARACTERS || |
| myNode.getElementType() == XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN; |
| } |
| |
| private static boolean isComment(final ASTNode node) { |
| final PsiElement psiElement = SourceTreeToPsiMap.treeElementToPsi(node); |
| if (psiElement instanceof PsiComment) return true; |
| final ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(psiElement.getLanguage()); |
| if (parserDefinition == null) return false; |
| final TokenSet commentTokens = parserDefinition.getCommentTokens(); |
| return commentTokens.contains(node.getElementType()); |
| } |
| |
| public void setXmlFormattingPolicy(final XmlFormattingPolicy xmlFormattingPolicy) { |
| myXmlFormattingPolicy = xmlFormattingPolicy; |
| } |
| |
| protected boolean buildInjectedPsiBlocks(List<Block> result, final ASTNode child, Wrap wrap, Alignment alignment, Indent indent) { |
| if (myInjectedBlockBuilder.addInjectedBlocks(result, child, wrap, alignment, indent)) { |
| return true; |
| } |
| |
| PsiFile containingFile = child.getPsi().getContainingFile(); |
| FileViewProvider fileViewProvider = containingFile.getViewProvider(); |
| |
| if (fileViewProvider instanceof TemplateLanguageFileViewProvider) { |
| Language templateLanguage = ((TemplateLanguageFileViewProvider)fileViewProvider).getTemplateDataLanguage(); |
| PsiElement at = fileViewProvider.findElementAt(child.getStartOffset(), templateLanguage); |
| |
| if (at instanceof XmlToken) { |
| at = at.getParent(); |
| } |
| |
| // TODO: several comments |
| if (at instanceof PsiComment && |
| at.getTextRange().equals(child.getTextRange()) && |
| at.getNode() != child) { |
| return buildInjectedPsiBlocks(result, at.getNode(), wrap, alignment, indent); |
| } |
| } |
| |
| return false; |
| } |
| |
| public boolean isCDATAStart() { |
| return myNode.getElementType() == XmlTokenType.XML_CDATA_START; |
| } |
| |
| public boolean isCDATAEnd() { |
| return myNode.getElementType() == XmlTokenType.XML_CDATA_END; |
| } |
| |
| public static boolean containsWhiteSpacesOnly(@NotNull ASTNode node) { |
| PsiElement psiElement = node.getPsi(); |
| if (psiElement instanceof PsiWhiteSpace) return true; |
| Language nodeLang = psiElement.getLanguage(); |
| if (!nodeLang.isKindOf(XMLLanguage.INSTANCE) || |
| isTextOnlyNode(node) || |
| node.getElementType() == XmlElementType.XML_PROLOG) { |
| WhiteSpaceFormattingStrategy strategy = WhiteSpaceFormattingStrategyFactory.getStrategy(nodeLang); |
| int length = node.getTextLength(); |
| return strategy.check(node.getChars(), 0, length) >= length; |
| } |
| return false; |
| } |
| |
| private static boolean isTextOnlyNode(@NotNull ASTNode node) { |
| if (node.getPsi() instanceof XmlText) return true; |
| ASTNode firstChild = node.getFirstChildNode(); |
| ASTNode lastChild = node.getLastChildNode(); |
| if (firstChild != null && firstChild == lastChild && firstChild.getPsi() instanceof XmlText) { |
| return true; |
| } |
| return false; |
| } |
| |
| } |
