play.utils.HTML Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of framework Show documentation
RePlay is a fork of the Play1 framework, created by Codeborne.
There is a newer version: 2.6.2
package play.utils;

import static java.util.Objects.requireNonNullElse;
import static org.apache.commons.lang3.StringUtils.isEmpty;

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 (isEmpty(input)) {
      return input;
    }
    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 reference 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 propertes.
      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, (char) referredChar);
      }
    }

    /**
     * Return the number of supported entity references.
     *
     * @return 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.
     *
     * @param character The given character
     * @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.
     *
     * @param character The given character
     * @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);
        return this.characterToEntityReferenceMap[index];
      }
      return null;
    }

    /**
     * Return the char mapped to the given entityReference or -1.
     *
     * @param entityReference The given entityReference
     * @return The char mapped to the given entityReference or -1.
     */
    public char convertToCharacter(String entityReference) {
      Character referredCharacter = this.entityReferenceToCharacterMap.get(entityReference);
      return requireNonNullElse(referredCharacter, CHAR_NULL);
    }
  }
}