/*******************************************************************************
* Copyright (c) 2004, 2011 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsp.core.internal.text;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentPartitioner;
import org.eclipse.jst.jsp.core.internal.encoding.JSPDocumentHeadContentDetector;
import org.eclipse.jst.jsp.core.internal.parser.JSPSourceParser;
import org.eclipse.jst.jsp.core.internal.provisional.JSP11Namespace;
import org.eclipse.jst.jsp.core.internal.provisional.JSP12Namespace;
import org.eclipse.jst.jsp.core.internal.regions.DOMJSPRegionContexts;
import org.eclipse.jst.jsp.core.text.IJSPPartitions;
import org.eclipse.wst.html.core.internal.text.StructuredTextPartitionerForHTML;
import org.eclipse.wst.sse.core.internal.ltk.parser.RegionParser;
import org.eclipse.wst.sse.core.internal.ltk.parser.TagMarker;
import org.eclipse.wst.sse.core.internal.parser.ForeignRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredTextPartitioner;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionContainer;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
import org.eclipse.wst.sse.core.internal.text.rules.IStructuredTypedRegion;
import org.eclipse.wst.sse.core.internal.text.rules.StructuredTextPartitioner;
import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
import org.eclipse.wst.xml.core.internal.text.rules.StructuredTextPartitionerForXML;
public class StructuredTextPartitionerForJSP extends StructuredTextPartitioner {
// for compatibility with v5.1.0, we'll reuse ST_JSP_DIRECTIVE for action
// tags
private final static boolean fEnableJSPActionPartitions = true;
// list of valid JSP 1.2 tag and action names
private static List fJSPActionTagNames = null;
private static final String HTML_MIME_TYPE = "text/html"; //$NON-NLS-1$
private static final String XHTML_MIME_TYPE = "text/xhtml"; //$NON-NLS-1$
private static final String XML_MIME_TYPE = "text/xml"; //$NON-NLS-1$
private static final String VND_WAP_WML = "text/vnd.wap.wml"; //$NON-NLS-1$
private final static String[] fConfiguredContentTypes = new String[]{IJSPPartitions.JSP_DEFAULT, IJSPPartitions.JSP_DEFAULT_EL, IJSPPartitions.JSP_DEFAULT_EL2, IJSPPartitions.JSP_DIRECTIVE, IJSPPartitions.JSP_CONTENT_DELIMITER, IJSPPartitions.JSP_CONTENT_JAVA, IJSPPartitions.JSP_CONTENT_JAVASCRIPT, IJSPPartitions.JSP_COMMENT};
/**
* @return
*/
public static String[] getConfiguredContentTypes() {
return fConfiguredContentTypes;
}
private IStructuredTextPartitioner fEmbeddedPartitioner = null;
/*
* Save last taglib prefix that was checked (see isAction()) for better
* performance
*/
private String fLastCheckedPrefix = null;
/**
* Assume language=java by default ... client, such as
* PageDirectiveAdapter, must set language of document partitioner,
* if/when it changes.
*/
private String fLanguage = "java"; //$NON-NLS-1$
/**
* Constructor for JSPDocumentPartioner.
*/
public StructuredTextPartitionerForJSP() {
super();
if (fJSPActionTagNames == null) {
fJSPActionTagNames = new ArrayList(); // uses .equals() for
// contains()
fJSPActionTagNames.add(JSP12Namespace.ElementName.DECLARATION);
// fJSPActionTagNames.add(JSP12Namespace.ElementName.DIRECTIVE_INCLUDE);
// fJSPActionTagNames.add(JSP12Namespace.ElementName.DIRECTIVE_PAGE);
// fJSPActionTagNames.add(JSP12Namespace.ElementName.DIRECTIVE_TAGLIB);
fJSPActionTagNames.add(JSP12Namespace.ElementName.EXPRESSION);
fJSPActionTagNames.add(JSP12Namespace.ElementName.FALLBACK);
fJSPActionTagNames.add(JSP12Namespace.ElementName.FORWARD);
fJSPActionTagNames.add(JSP12Namespace.ElementName.GETPROPERTY);
fJSPActionTagNames.add(JSP12Namespace.ElementName.INCLUDE);
fJSPActionTagNames.add(JSP12Namespace.ElementName.PARAM);
fJSPActionTagNames.add(JSP12Namespace.ElementName.PARAMS);
fJSPActionTagNames.add(JSP12Namespace.ElementName.PLUGIN);
// fJSPActionTagNames.add(JSP12Namespace.ElementName.ROOT);
fJSPActionTagNames.add(JSP12Namespace.ElementName.SCRIPTLET);
fJSPActionTagNames.add(JSP12Namespace.ElementName.SETPROPERTY);
fJSPActionTagNames.add(JSP12Namespace.ElementName.TEXT);
fJSPActionTagNames.add(JSP12Namespace.ElementName.USEBEAN);
}
}
/**
* @see org.eclipse.jface.text.IDocumentPartitioner#connect(org.eclipse.jface.text.IDocument)
*/
public void connect(IDocument document) {
super.connect(document);
fSupportedTypes = null;
}
private IStructuredTextPartitioner createStructuredTextPartitioner(IStructuredDocument structuredDocument) {
IStructuredTextPartitioner result = null;
// this same detector should underly content describer, to have consistent results
JSPDocumentHeadContentDetector jspHeadContentDetector = new JSPDocumentHeadContentDetector();
jspHeadContentDetector.set(structuredDocument);
String contentType = null;
try {
contentType = jspHeadContentDetector.getContentType();
// if XHTML or WML, that trumps what is in the page directive
if (jspHeadContentDetector.isXHTML() || jspHeadContentDetector.isWML()) {
contentType = "text/html";
}
}
catch (IOException e) {
// impossible in this context, since working with document stream
throw new Error(e);
}
// null or empty, treat as "default"
if (contentType == null || contentType.length() == 0) {
contentType = "text/html"; //$NON-NLS-1$
}
// we currently only have two ... eventually should
// make or tie-in to existing registry.
if (contentType.equalsIgnoreCase(HTML_MIME_TYPE) || contentType.equalsIgnoreCase(VND_WAP_WML)) {
result = new StructuredTextPartitionerForHTML();
result.connect(structuredDocument);
}
else if (contentType.equalsIgnoreCase(XHTML_MIME_TYPE)) {
result = new StructuredTextPartitionerForHTML();
result.connect(structuredDocument);
}
else if (contentType.equalsIgnoreCase(XML_MIME_TYPE) || contentType.endsWith("+xml")) { //$NON-NLS-1$
result = new StructuredTextPartitionerForXML();
result.connect(structuredDocument);
}
else {
result = new StructuredTextPartitioner();
result.connect(structuredDocument);
}
return result;
}
/**
* @see org.eclipse.jface.text.IDocumentPartitioner#disconnect()
*/
public void disconnect() {
if (fEmbeddedPartitioner != null) {
fEmbeddedPartitioner.disconnect();
// https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=4909
/**
* force recreation when reconnected
*/
fEmbeddedPartitioner = null;
}
// super.disconnect should come at end, since it (may) set
// structuredDocument to null
super.disconnect();
}
public String getDefaultPartitionType() {
return getEmbeddedPartitioner().getDefaultPartitionType();
}
/**
* Returns the embeddedPartitioner.
*
* @return IStructuredTextPartitioner
*/
public IStructuredTextPartitioner getEmbeddedPartitioner() {
if (fEmbeddedPartitioner == null) {
fEmbeddedPartitioner = createStructuredTextPartitioner(fStructuredDocument);
fEmbeddedPartitioner.connect(fStructuredDocument);
}
return fEmbeddedPartitioner;
}
/**
* Returns the language.
*
* @return String
*/
public String getLanguage() {
return fLanguage;
}
private List getLocalLegalContentTypes() {
List types = new ArrayList();
Object[] configuredTypes = getConfiguredContentTypes();
for (int i = 0; i < configuredTypes.length; i++)
types.add(configuredTypes[i]);
return types;
}
private String getParentName(IStructuredDocumentRegion sdRegion) {
String result = "UNKNOWN"; //$NON-NLS-1$
while (sdRegion != null && isValidJspActionRegionType(sdRegion.getType()))
sdRegion = sdRegion.getPrevious();
if (sdRegion != null) {
ITextRegionList regions = sdRegion.getRegions();
// only find parent names from a start tag
if (regions.size() > 1) {
ITextRegion r = regions.get(1);
if (regions.get(0).getType().equals(DOMRegionContext.XML_TAG_OPEN) && r.getType().equals(DOMRegionContext.XML_TAG_NAME)) {
result = sdRegion.getText(r);
}
}
}
return result;
}
protected String getPartitionType(ForeignRegion region, int offset) {
return getEmbeddedPartitioner().getPartitionType(region, offset);
}
public String getPartitionType(ITextRegion region, int offset) {
String result = null;
final String region_type = region.getType();
if (region_type == DOMJSPRegionContexts.JSP_CONTENT) {
result = getPartitionTypeForDocumentLanguage();
}
else if (region_type == DOMJSPRegionContexts.JSP_COMMENT_TEXT || region_type == DOMJSPRegionContexts.JSP_COMMENT_OPEN || region_type == DOMJSPRegionContexts.JSP_COMMENT_CLOSE)
result = IJSPPartitions.JSP_COMMENT;
else if (region_type == DOMJSPRegionContexts.JSP_DIRECTIVE_NAME || region_type == DOMJSPRegionContexts.JSP_DIRECTIVE_OPEN || region_type == DOMJSPRegionContexts.JSP_DIRECTIVE_CLOSE)
result = IJSPPartitions.JSP_DIRECTIVE;
else if (region_type == DOMJSPRegionContexts.JSP_CLOSE || region_type == DOMJSPRegionContexts.JSP_SCRIPTLET_OPEN || region_type == DOMJSPRegionContexts.JSP_EXPRESSION_OPEN || region_type == DOMJSPRegionContexts.JSP_DECLARATION_OPEN)
result = IJSPPartitions.JSP_CONTENT_DELIMITER;
else if (region_type == DOMJSPRegionContexts.JSP_ROOT_TAG_NAME)
result = IJSPPartitions.JSP_DEFAULT;
else if (region_type == DOMJSPRegionContexts.JSP_EL_OPEN || region_type == DOMJSPRegionContexts.JSP_EL_CONTENT || region_type == DOMJSPRegionContexts.JSP_EL_CLOSE || region_type == DOMJSPRegionContexts.JSP_EL_DQUOTE || region_type == DOMJSPRegionContexts.JSP_EL_SQUOTE || region_type == DOMJSPRegionContexts.JSP_EL_QUOTED_CONTENT)
result = IJSPPartitions.JSP_DEFAULT_EL;
else if (region_type == DOMJSPRegionContexts.JSP_VBL_OPEN || region_type == DOMJSPRegionContexts.JSP_VBL_CONTENT || region_type == DOMJSPRegionContexts.JSP_VBL_CLOSE || region_type == DOMJSPRegionContexts.JSP_VBL_DQUOTE || region_type == DOMJSPRegionContexts.JSP_VBL_SQUOTE || region_type == DOMJSPRegionContexts.JSP_VBL_QUOTED_CONTENT)
result = IJSPPartitions.JSP_DEFAULT_EL2;
else if (region_type == DOMJSPRegionContexts.XML_TAG_ATTRIBUTE_VALUE_DQUOTE || region_type == DOMJSPRegionContexts.XML_TAG_ATTRIBUTE_VALUE_SQUOTE)
result = IJSPPartitions.JSP_DEFAULT;
else if (region_type == DOMRegionContext.XML_CDATA_TEXT) {
// BUG131463: possibly between <jsp:scriptlet>, <jsp:expression>,
// <jsp:declaration>
IStructuredDocumentRegion sdRegion = this.fStructuredDocument.getRegionAtCharacterOffset(offset);
if (isJspJavaActionName(getParentName(sdRegion)))
result = getPartitionTypeForDocumentLanguage();
else
result = getEmbeddedPartitioner().getPartitionType(region, offset);
}
else if (region_type == DOMRegionContext.XML_CONTENT) {
// possibly between <jsp:scriptlet>, <jsp:expression>,
// <jsp:declaration>
IStructuredDocumentRegion sdRegion = this.fStructuredDocument.getRegionAtCharacterOffset(offset);
if (isJspJavaActionName(getParentName(sdRegion)))
result = getPartitionTypeForDocumentLanguage();
else
result = getDefaultPartitionType();
}
// else if (region_type == DOMRegionContext.BLOCK_TEXT) {
// possibly between <jsp:scriptlet>, <jsp:expression>,
// <jsp:declaration>
// IStructuredDocumentRegion sdRegion = this.fStructuredDocument.getRegionAtCharacterOffset(offset);
// if (isJspJavaActionName(getParentName(sdRegion)))
// result = getPartitionTypeForDocumentLanguage();
// else
// result = getDefaultPartitionType();
// }
else {
result = getEmbeddedPartitioner().getPartitionType(region, offset);
}
return result;
}
public String getPartitionTypeBetween(IStructuredDocumentRegion previousNode, IStructuredDocumentRegion nextNode) {
return getEmbeddedPartitioner().getPartitionTypeBetween(previousNode, nextNode);
}
private String getPartitionTypeForDocumentLanguage() {
String result;
if (fLanguage == null || fLanguage.equalsIgnoreCase("java")) { //$NON-NLS-1$
result = IJSPPartitions.JSP_CONTENT_JAVA;
}
else if (fLanguage.equalsIgnoreCase("javascript")) { //$NON-NLS-1$
result = IJSPPartitions.JSP_CONTENT_JAVASCRIPT;
}
else {
result = IJSPPartitions.JSP_SCRIPT_PREFIX + getLanguage().toUpperCase(Locale.ENGLISH);
}
return result;
}
protected void initLegalContentTypes() {
List combinedTypes = getLocalLegalContentTypes();
if (getEmbeddedPartitioner() != null) {
String[] moreTypes = getEmbeddedPartitioner().getLegalContentTypes();
for (int i = 0; i < moreTypes.length; i++)
combinedTypes.add(moreTypes[i]);
}
fSupportedTypes = new String[0];
combinedTypes.toArray(fSupportedTypes);
}
/**
* @param sdRegion
* @param offset
* @return
*/
private boolean isAction(IStructuredDocumentRegion sdRegion, int offset) {
if (!sdRegion.getType().equals(DOMRegionContext.XML_TAG_NAME))
return false;
/*
* shouldn't get a tag name region type unless a tag name region
* exists at [1]
*/
ITextRegion tagNameRegion = sdRegion.getRegions().get(1);
String tagName = sdRegion.getText(tagNameRegion);
RegionParser parser = fStructuredDocument.getParser();
if (parser instanceof JSPSourceParser) {
if (tagName.equals(fLastCheckedPrefix))
return true;
List fCustomActionPrefixes = ((JSPSourceParser) parser).getNestablePrefixes();
for (int i = 0; i < fCustomActionPrefixes.size(); i++)
if (tagName.startsWith(((TagMarker) fCustomActionPrefixes.get(i)).getTagName())) {
fLastCheckedPrefix = ((TagMarker) fCustomActionPrefixes.get(i)).getTagName();
return true;
}
}
return false;
}
protected boolean isDocumentRegionBasedPartition(IStructuredDocumentRegion sdRegion, ITextRegion containedChildRegion, int offset) {
String documentRegionContext = sdRegion.getType();
if (containedChildRegion != null) {
if (documentRegionContext.equals(DOMJSPRegionContexts.JSP_DIRECTIVE_NAME) || documentRegionContext.equals(DOMJSPRegionContexts.JSP_ROOT_TAG_NAME)) {
setInternalPartition(offset, containedChildRegion.getLength(), IJSPPartitions.JSP_DIRECTIVE);
return true;
}
//if is a JSP custom tag but not a JSP_EL region
if (fEnableJSPActionPartitions && !isELRegion(containedChildRegion) && !isScriptletRegion(containedChildRegion) && isAction(sdRegion, offset) && !(containedChildRegion instanceof ITextRegionContainer) ) {
setInternalPartition(offset, containedChildRegion.getLength(), IJSPPartitions.JSP_DIRECTIVE);
return true;
}
}
return super.isDocumentRegionBasedPartition(sdRegion, containedChildRegion, offset);
}
/**
* @param possibleJspJavaAction
* @return
*/
private boolean isJspJavaActionName(String possibleJspJavaAction) {
return possibleJspJavaAction.equals(JSP11Namespace.ElementName.SCRIPTLET) || possibleJspJavaAction.equals(JSP11Namespace.ElementName.EXPRESSION) || possibleJspJavaAction.equals(JSP11Namespace.ElementName.DECLARATION);
}
private boolean isValidJspActionRegionType(String type) {
// true for anything that can be within <jsp:scriptlet>,
// <jsp:expression>, <jsp:declaration>
return type == DOMRegionContext.XML_CONTENT || type == DOMRegionContext.BLOCK_TEXT || type == DOMRegionContext.XML_CDATA_OPEN || type == DOMRegionContext.XML_CDATA_TEXT || type == DOMRegionContext.XML_CDATA_CLOSE;
}
public IDocumentPartitioner newInstance() {
StructuredTextPartitionerForJSP instance = new StructuredTextPartitionerForJSP();
instance.setEmbeddedPartitioner(createStructuredTextPartitioner(fStructuredDocument));
instance.setLanguage(fLanguage);
return instance;
}
/**
* Sets the embeddedPartitioner.
*
* @param embeddedPartitioner
* The embeddedPartitioner to set
*/
public void setEmbeddedPartitioner(IStructuredTextPartitioner embeddedPartitioner) {
// https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=4909
/**
* manage connected state of embedded partitioner
*/
if (fEmbeddedPartitioner != null && fStructuredDocument != null) {
fEmbeddedPartitioner.disconnect();
}
this.fEmbeddedPartitioner = embeddedPartitioner;
if (fEmbeddedPartitioner != null && fStructuredDocument != null) {
fEmbeddedPartitioner.connect(fStructuredDocument);
}
}
protected void setInternalPartition(int offset, int length, String type) {
// TODO: need to carry this single instance idea further to be
// complete,
// but hopefully this will be less garbage than before (especially for
// HTML, XML,
// naturally!)
IStructuredTypedRegion region = getEmbeddedPartitioner().createPartition(offset, length, type);
super.setInternalPartition(region.getOffset(), region.getLength(), region.getType());
}
/**
* Sets the language.
*
* @param language
* The language to set
*/
public void setLanguage(String language) {
this.fLanguage = language;
}
/**
* @param region decide if this region is an EL region
* @return <code>true</code> if the given <code>region</code> is a EL region,
* <code>false</code> otherwise.
*/
private boolean isELRegion(ITextRegion region) {
String type = region.getType();
return
type == DOMJSPRegionContexts.JSP_EL_CLOSE ||
type == DOMJSPRegionContexts.JSP_EL_CONTENT ||
type == DOMJSPRegionContexts.JSP_EL_DQUOTE ||
type == DOMJSPRegionContexts.JSP_EL_OPEN ||
type == DOMJSPRegionContexts.JSP_EL_QUOTED_CONTENT ||
type == DOMJSPRegionContexts.JSP_EL_SQUOTE ||
type == DOMJSPRegionContexts.JSP_VBL_CLOSE ||
type == DOMJSPRegionContexts.JSP_VBL_CONTENT ||
type == DOMJSPRegionContexts.JSP_VBL_DQUOTE ||
type == DOMJSPRegionContexts.JSP_VBL_OPEN ||
type == DOMJSPRegionContexts.JSP_VBL_QUOTED_CONTENT ||
type == DOMJSPRegionContexts.JSP_VBL_SQUOTE;
}
private boolean isScriptletRegion(ITextRegion region) {
final String type = region.getType();
return type == DOMJSPRegionContexts.JSP_SCRIPTLET_OPEN || type == DOMJSPRegionContexts.JSP_CLOSE || type == DOMJSPRegionContexts.JSP_EXPRESSION_OPEN || type == DOMJSPRegionContexts.JSP_DECLARATION_OPEN || type == DOMJSPRegionContexts.JSP_CONTENT;
}
/* (non-Javadoc)
* @see org.eclipse.wst.sse.core.internal.text.rules.StructuredTextPartitioner#doParserSpecificCheck(int, boolean, org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion, org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion, org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion, org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion)
*/
protected boolean doParserSpecificCheck(int offset, boolean partitionFound, IStructuredDocumentRegion sdRegion, IStructuredDocumentRegion previousStructuredDocumentRegion, ITextRegion next, ITextRegion previousStart) {
if (previousStart != null && previousStart.getType() == DOMRegionContext.XML_TAG_OPEN && next.getType() == DOMRegionContext.XML_END_TAG_OPEN) {
ITextRegion previousName = previousStructuredDocumentRegion.getRegionAtCharacterOffset(previousStructuredDocumentRegion.getEndOffset(previousStart));
ITextRegion nextName = sdRegion.getRegionAtCharacterOffset(sdRegion.getEndOffset(next));
if (previousName != null && nextName != null && previousName.getType() == DOMRegionContext.XML_TAG_NAME && nextName.getType() == DOMRegionContext.XML_TAG_NAME) {
setInternalPartition(offset, 0, getPartitionTypeBetween(previousStructuredDocumentRegion, sdRegion));
partitionFound = true;
}
}
return partitionFound;
}
/* (non-Javadoc)
* @see org.eclipse.wst.sse.core.internal.text.rules.StructuredTextPartitioner#getParserSpecificPreviousRegion(org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion)
*/
protected IStructuredDocumentRegion getParserSpecificPreviousRegion(IStructuredDocumentRegion currentRegion) {
if (currentRegion == null)
return null;
do {
currentRegion = currentRegion.getPrevious();
} while (currentRegion != null && currentRegion.getType().equals(DOMRegionContext.BLOCK_TEXT));
return currentRegion;
}
}