/*******************************************************************************
* Copyright (c) 2004, 2006 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
* Oracle - copy and modify ContentDescriberForHTML
*******************************************************************************/
package org.eclipse.jst.jsf.core.internal.contenttype;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.regex.Pattern;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.content.IContentDescriber;
import org.eclipse.core.runtime.content.IContentDescription;
import org.eclipse.core.runtime.content.ITextContentDescriber;
import org.eclipse.wst.html.core.internal.contenttype.HTMLResourceEncodingDetector;
import org.eclipse.wst.sse.core.internal.encoding.EncodingMemento;
import org.eclipse.wst.sse.core.internal.encoding.IContentDescriptionExtended;
import org.eclipse.wst.sse.core.internal.encoding.IResourceCharsetDetector;
import org.eclipse.wst.sse.core.utils.StringUtils;
import org.eclipse.wst.xml.core.internal.parser.XMLTokenizer;
import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
/**
* Copied from ContentDescriberForHTML, since that class is final but we need to add description
* criteria.
*/
public abstract class AbstractContentDescriberForFacelets implements ITextContentDescriber {
/**
* Get the patterns to match against value of namespace attributes (of the document element).
* @return Array of Pattern instances to match against value of namespace attributes (of the
* document element).
*/
protected abstract Pattern[] getNSValuePatterns();
final private static QualifiedName[] SUPPORTED_OPTIONS = {IContentDescription.CHARSET, IContentDescription.BYTE_ORDER_MARK, IContentDescriptionExtended.DETECTED_CHARSET, IContentDescriptionExtended.UNSUPPORTED_CHARSET, IContentDescriptionExtended.APPROPRIATE_DEFAULT};
public int describe(InputStream contents, IContentDescription description) throws IOException {
int result = IContentDescriber.INDETERMINATE;
byte[] bom = null;
if (description != null) {
calculateSupportedOptions(contents, description);
Object value = description.getProperty(IContentDescription.BYTE_ORDER_MARK);
if (value instanceof byte[]) {
bom = (byte[])value;
}
} else {
contents.reset();
bom = getByteOrderMark(contents);
}
Object value =
(description != null ? description.getProperty(IContentDescription.CHARSET) : null);
String charsetName = null;
if (value != null) {
charsetName = value.toString();
} else {
if (Arrays.equals(IContentDescription.BOM_UTF_16BE, bom)) {
charsetName = "UTF-16BE"; //$NON-NLS-1$
} else if (Arrays.equals(IContentDescription.BOM_UTF_16LE, bom)) {
charsetName = "UTF-16LE"; //$NON-NLS-1$
} else {
charsetName = "UTF-8"; //$NON-NLS-1$
}
}
contents.reset();
result = checkCriteria(new InputStreamReader(contents, Charset.forName(charsetName)));
return result;
}
public int describe(Reader contents, IContentDescription description) throws IOException {
int result = IContentDescriber.INDETERMINATE;
if (description != null) {
calculateSupportedOptions(contents, description);
}
contents.reset();
result = checkCriteria(contents);
return result;
}
public QualifiedName[] getSupportedOptions() {
return SUPPORTED_OPTIONS;
}
private void calculateSupportedOptions(InputStream contents, IContentDescription description) throws IOException {
if (isRelevent(description)) {
IResourceCharsetDetector detector = getDetector();
detector.set(contents);
handleCalculations(description, detector);
}
}
private void calculateSupportedOptions(Reader contents, IContentDescription description) throws IOException {
if (isRelevent(description)) {
IResourceCharsetDetector detector = getDetector();
detector.set(contents);
handleCalculations(description, detector);
}
}
private IResourceCharsetDetector getDetector() {
return new HTMLResourceEncodingDetector();
}
private void handleCalculations(IContentDescription description, IResourceCharsetDetector detector) throws IOException {
EncodingMemento encodingMemento = ((HTMLResourceEncodingDetector) detector).getEncodingMemento();
Object detectedByteOrderMark = encodingMemento.getUnicodeBOM();
if (detectedByteOrderMark != null) {
Object existingByteOrderMark = description.getProperty(IContentDescription.BYTE_ORDER_MARK);
if (!detectedByteOrderMark.equals(existingByteOrderMark)) {
description.setProperty(IContentDescription.BYTE_ORDER_MARK, detectedByteOrderMark);
}
}
if (!encodingMemento.isValid()) {
description.setProperty(IContentDescriptionExtended.UNSUPPORTED_CHARSET, encodingMemento.getInvalidEncoding());
description.setProperty(IContentDescriptionExtended.APPROPRIATE_DEFAULT, encodingMemento.getAppropriateDefault());
}
Object detectedCharset = encodingMemento.getDetectedCharsetName();
Object javaCharset = encodingMemento.getJavaCharsetName();
if (detectedCharset != null) {
description.setProperty(IContentDescriptionExtended.DETECTED_CHARSET, detectedCharset);
}
if (javaCharset != null) {
Object existingCharset = description.getProperty(IContentDescription.CHARSET);
if (!javaCharset.equals(existingCharset)) {
Object defaultCharset = detector.getSpecDefaultEncoding();
if (defaultCharset != null) {
if (!defaultCharset.equals(javaCharset)) {
description.setProperty(IContentDescription.CHARSET, javaCharset);
}
} else {
description.setProperty(IContentDescription.CHARSET, javaCharset);
}
}
}
}
private boolean isRelevent(IContentDescription description) {
boolean result = false;
if (description != null) {
if (description.isRequested(IContentDescription.BYTE_ORDER_MARK)) {
result = true;
} else if (description.isRequested(IContentDescription.CHARSET)) {
result = true;
} else if (description.isRequested(IContentDescriptionExtended.APPROPRIATE_DEFAULT)) {
result = true;
} else if (description.isRequested(IContentDescriptionExtended.DETECTED_CHARSET)) {
result = true;
} else if (description.isRequested(IContentDescriptionExtended.UNSUPPORTED_CHARSET)) {
result = true;
}
}
return result;
}
private int checkCriteria(Reader contents) throws IOException {
final Pattern[] nsValuePatterns = getNSValuePatterns();
if (nsValuePatterns == null || nsValuePatterns.length == 0) {
return INVALID;
}
final Pattern nsNamePattern = Pattern.compile("xmlns:.*"); //$NON-NLS-1$
String attributeName = null;
String attributeValue = null;
XMLTokenizer tokenizer = new XMLTokenizer(contents);
String token = tokenizer.primGetNextToken();
while (token != null &&
!DOMRegionContext.XML_TAG_CLOSE.equals(token) &&
!DOMRegionContext.XML_EMPTY_TAG_CLOSE.equals(token)) {
if (DOMRegionContext.XML_TAG_ATTRIBUTE_NAME.equals(token)) {
attributeName = tokenizer.yytext();
}
else if (DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE.equals(token)) {
attributeValue = StringUtils.strip(tokenizer.yytext());
for (int i = 0; i < nsValuePatterns.length; i++) {
if (nsNamePattern.matcher(attributeName).matches()) {
if (nsValuePatterns[i].matcher(attributeValue).matches()) {
return VALID;
}
}
}
}
token = tokenizer.primGetNextToken();
}
return INVALID;
}
private static byte[] getByteOrderMark(InputStream contents) throws IOException {
int first = contents.read();
if (first == 0xEF) {
// look for the UTF-8 Byte Order Mark (BOM)
int second = contents.read();
int third = contents.read();
if (second == 0xBB && third == 0xBF)
return IContentDescription.BOM_UTF_8;
}
else if (first == 0xFE) {
// look for the UTF-16 BOM
if (contents.read() == 0xFF)
return IContentDescription.BOM_UTF_16BE;
}
else if (first == 0xFF) {
if (contents.read() == 0xFE)
return IContentDescription.BOM_UTF_16LE;
}
return null;
}
}