play.utils.HTML Maven / Gradle / Ivy

package play.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/*
 * Copyright 2002-2005 the original author or authors.
 *
 * 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.
 *
 * Represents a set of character entity references defined by the
 * HTML 4.0 standard.
 *
 * A complete description of the HTML 4.0 character set can be found
 * at http://www.w3.org/TR/html4/charset.html.
 *
 * @author Juergen Hoeller
 * @author Martin Kersten
 * @since 1.2.1
 */
public class HTML {

    /*
     * Shared instance of pre-parsed HTML character entity references.
     */
    private static final HtmlCharacterEntityReferences characterEntityReferences = new HtmlCharacterEntityReferences();

    /**
     * Turn special characters into HTML character references.
     * Handles complete character set defined in HTML 4.01 recommendation.
     * 
Escapes all special characters to their corresponding
     * entity reference (e.g. <).
     * Reference:
     * 
     * http://www.w3.org/TR/html4/sgml/entities.html
     * 
     * @param input the (unescaped) input string
     * @return the escaped string
     */
    public static String htmlEscape(String input) {
        if (input == null) {
            return null;
        }
        StringBuilder escaped = new StringBuilder(input.length() * 2);
        for (int i = 0; i < input.length(); i++) {
            char character = input.charAt(i);
            String reference = characterEntityReferences.convertToReference(character);
            if (reference != null) {
                escaped.append(reference);
            } else {
                escaped.append(character);
            }
        }
        return escaped.toString();
    }

    public static class HtmlCharacterEntityReferences {

        static final char REFERENCE_START = '&';
        static final String DECIMAL_REFERENCE_START = "&#";
        static final String HEX_REFERENCE_START = "&#x";
        static final char REFERENCE_END = ';';
        static final char CHAR_NULL = (char) -1;
        private static final String PROPERTIES_FILE = "htmlentities.properties";
        private final String[] characterToEntityReferenceMap = new String[3000];
        private final Map entityReferenceToCharacterMap = new HashMap(252);

        /**
         * Returns a new set of character entity references reflecting the HTML 4.0 character set.
         */
        public HtmlCharacterEntityReferences() {
            Properties entityReferences = new Properties();

            // Load refeence definition file.
            InputStream is = HtmlCharacterEntityReferences.class.getResourceAsStream(PROPERTIES_FILE);
            if (is == null) {
                throw new IllegalStateException(
                        "Cannot find reference definition file [htmlentities.properties] as class path resource");
            }
            try {
                try {
                    entityReferences.load(is);
                } finally {
                    is.close();
                }
            } catch (IOException ex) {
                throw new IllegalStateException(
                        "Failed to parse reference definition file [HtmlCharacterEntityReferences.properties]: " + ex.getMessage());
            }

            // Parse reference definition properites.
            Enumeration keys = entityReferences.propertyNames();
            while (keys.hasMoreElements()) {
                String key = (String) keys.nextElement();
                int referredChar = Integer.parseInt(key);
                int index = (referredChar < 1000 ? referredChar : referredChar - 7000);
                String reference = entityReferences.getProperty(key);
                this.characterToEntityReferenceMap[index] = REFERENCE_START + reference + REFERENCE_END;
                this.entityReferenceToCharacterMap.put(reference, new Character((char) referredChar));
            }
        }

        /**
         * Return the number of supported entity references.
         */
        public int getSupportedReferenceCount() {
            return this.entityReferenceToCharacterMap.size();
        }

        /**
         * Return true if the given character is mapped to a supported entity reference.
         */
        public boolean isMappedToReference(char character) {
            return (convertToReference(character) != null);
        }

        /**
         * Return the reference mapped to the given character or null.
         */
        public String convertToReference(char character) {
            if (character < 1000 || (character >= 8000 && character < 10000)) {
                int index = (character < 1000 ? character : character - 7000);
                String entityReference = this.characterToEntityReferenceMap[index];
                if (entityReference != null) {
                    return entityReference;
                }
            }
            return null;
        }

        /**
         * Return the char mapped to the given entityReference or -1.
         */
        public char convertToCharacter(String entityReference) {
            Character referredCharacter = this.entityReferenceToCharacterMap.get(entityReference);
            if (referredCharacter != null) {
                return referredCharacter.charValue();
            }
            return CHAR_NULL;
        } 
    }
}