sunlabs.brazil.handler.HtmlRewriter Maven / Gradle / Ivy

* The user can sequentially examine and rewrite each token in the source * HTML document. As each token in the document is seen, the user has * two choices:

*
• modify the current token. *
• don't modify the current token. *

* Parsing is implemented lazily, meaning, for example, that unless the * user actually asks for attributes of an HTML tag, this parser * does not have to spend the time breaking up the attributes. *

* This class is used by HTML filters to maintain the state of the * document and allow the filters to perform arbitrary rewriting. * * @author Colin Stevens ([email protected]) * @version @(#)HtmlRewriter.java 2.6 */ public class HtmlRewriter { /** * The parser for the source HTML document. */ public LexHTML lex; /** * Storage holding the resultant HTML document. */ public StringBuffer sb; /** * true if the last token was pushed back and should be * presented again next time. Made false once the * pushedback token is presented. */ boolean pushback; /** * true if nextToken should automatically * append unmodified tokens to the result. */ boolean accumulate; /** * true if the user has already explicitly appended * something, so nextToken shouldn't append the * unmodified token. */ boolean appendToken; /** * true if the user has modified the tag name or * attributes of the current tag, so when this tag is appended, we * need to write out its parts rather than just emitting the raw token. */ boolean tokenModified; int type; boolean singleton; String token; String tag; StringMap map; int tokenCount; // count tokens int tagCount; // count just tags /** * Creates a new HtmlRewriter from the given HTML parser. * * @param lex * The HTML parser. */ public HtmlRewriter(LexHTML lex) { this.lex = lex; sb = new StringBuffer(); accumulate = true; tokenCount=0; tagCount=0; } /** * Creates a new HtmlRewriter that will operate on the given * string. * * @param str * The HTML document. */ public HtmlRewriter(String str) { this(new LexHTML(str)); } /** * Returns the "new" rewritten HTML document. This is normally called * once all of the tokens have been processed, and the user wants to * send on this rewritten document. *

* At any time, this method can be called to return the current state * of the HTML document. The return value is the result of * processing the source document up to this point in time; the * unprocessed remainder of the source document is not considered. *

* Due to the implementation, calling this method may be expensive. * Specifically, calling this method a second (or further) time for * a given HtmlRewriter may involve copying temporary * strings around. The pessimal case would be to call this method * every time a new token is appended. * * @return The rewritten HTML document, up to this point in time. */ public String toString() { return sb.toString(); } /** * Advances to the next token in the source HTML document. *

* The other purpose of this function is to "do the right thing", which * is to append the token we just processed to the resultant HTML * document, unless the user has already appended something else. *

* A sample program follows. This program changes all * <img> tags to <form> tags, * deletes all <table> tags, capitalizes * and bolds each string token, and passes all other tokens through * unchanged, to illustrate how nextToken interacts with * some of the other methods in this class. *

     * HtmlRewriter hr = new HtmlRewriter(str);
     * while (hr.nextToken()) {
     *     switch (hr.getType()) {
     *     case LexHTML.TAG: 
     *         if (hr.getTag().equals("img")) {
     *             // Change the tag name w/o affecting the attributes.
     *             
     *             hr.setTag("form");
     *         } else if (hr.getTag().equals("table")) {
     *             // Eliminate the entire "table" token.
     *             
     *             hr.killToken();
     *         } 
     *         break;
     *             
     *     case LexHTML.STRING:
     *         // Append a new sequence in place of the existing token.
     *
     *         hr.append("<b>" + hr.getToken().toUpperCase() + "</b>");
     *         break;
     *     }
     *     // Any tokens we didn't modify get copied through unchanged.
     * }
     * 

*
• get("border") returns the empty string "". *
• get("rows") returns 2. *

* Surrounding single and double quote marks that occur in the literal * tag are removed from the values reported. So, for the tag * <a href="/foo.html" target=_top onclick='alert("hello")'>:

*
• get("href") returns /foo.html . *
• get("target") returns _top . *
• get("onclick") returns alert("hello") . *

* The value can be retrieved by calling get with a * key that is case-insensitive equal to the given key. *

* If the attributes already contained a mapping for the given key, * the old value is forgotten and the new specified value is used. * The case of the prior key is retained in that case. Otherwise * the case of the new key is used and a new mapping is made. * * @param key * The new key. May not be null. * * @param value * The new value. May be not be null. */ public void put(String key, String value) { getAttributes(); map.put(key, quote(value)); tokenModified = true; } /** * Removes the given case-insensitive key and its corresponding value * from the current tag's attributes. This method does nothing if the * key is not in the attributes. * * @param key * The key that needs to be removed. Must not be * null. */ public void remove(String key) { getAttributes(); map.remove(key); tokenModified = true; } /** * Returns an enumeration of the keys in the current tag's attributes. * The elements of the enumeration are the string keys. The keys can * be passed to get to get the values of the attributes. * * @return An enumeration of the keys. */ public Enumeration keys() { getAttributes(); return map.keys(); } /** * Instead of modifying an existing token, this method allows the user * to completely replace the current token with arbitrary new content. *

* This method may be called multiple times while processing the current * token to add more and more data to the resultant HTML document. * Before and/or after calling this method, the appendToken * method may also be called explicitly in order to add the current token * to the resultant HTML document. *

* Following is sample code illustrating how to use this method * to put bold tags around all the <a> tags. *

     * HtmlRewriter hr = new HtmlRewriter(str);
     * while (hr.nextTag()) {
     *     if (hr.getTag().equals("a")) {
     *         hr.append("<b>");
     *         hr.appendToken();
     *     } else if (hr.getTag().equals("/a")) {
     *         hr.appendToken();
     *         hr.append("</b>");
     *     }
     * }
     * 

* By default, this method is automatically called after each token is * processed unless the user has already appended something to the * resultant HTML document. Therefore, if the user appends something * and also wants to append the current token, or if the user wants * to append the current token a number of times, this method must * be called. * * @see #append * @see #killToken */ public void appendToken() { appendToken = false; if (tokenModified) { getTag(); getAttributes(); if (getType() == LexHTML.COMMENT) { sb.append("<--"); } else { sb.append('<'); } sb.append(tag); int length = map.size(); for (int i = 0; i < length; i++) { sb.append(' ').append(map.getKey(i)); String value = map.get(i); if ((value != null) && (value.length() > 0)) { sb.append('=').append(value); } } if (isSingleton()) { if (length > 0) { sb.append(' '); } sb.append('/'); } if (getType() == LexHTML.COMMENT) { sb.append("-->"); } else { sb.append('>'); } } else { sb.append(getToken()); } } /** * Tells this HtmlRewriter not to append the current token * to the resultant HTML document. Even if the user hasn't appended * anything else, the current token will be ignored rather than appended. * * @see #append * @see #killToken */ public void killToken() { appendToken = false; } /** * Turns on or off the automatic accumulation of each token. *

* After each token is processed, the current token is appended to * to the resultant HTML document unless the user has already appended * something else. By setting accumulate to * false, this behavior is turned off. The user must then * explicitly call appendToken to cause the current token * to be appended. *

* Turning off accumulation takes effect immediately, while turning * on accumulation takes effect on the next token. In other words, * whether the user turns this setting off or on, the current token * will not be added to the resultant HTML document unless the user * explicitly calls appendToken. *

* Following is sample code that illustrates how to use this method * to extract the contents of the <head> of the * source HTML document. *

     * HtmlRewriter hr = new HtmlRewriter(str);
     * // Don't accumulate tokens until we see the <head> below.
     * hr.accumulate(false);
     * while (hr.nextTag()) {
     *     if (hr.getTag().equals("head")) {
     *         // Start remembering the contents of the HTML document,
     *         // not including the <head> tag itself.
     *
     *         hr.accumulate(true);
     *     } else if (hr.getTag().equals("/head")) {
     *         // Return everything accumulated so far.
     *
     *         return hr.toString();
     *     }
     * }
     * 

* This is useful when a code fragment needs to read an indefinite * number of tokens, but that once some distinguished token is found, * needs to push that token back so that normal processing can occur * on that token. */ public void pushback() { pushback = true; } /** * Return count of tokens seen so far */ public int tokenCount() { return tokenCount; } /** * Return count of tags seen so far */ public int tagCount() { return tagCount; } /* * The set of characters that will turn-on quoting */ // public static String needQuote="' \t%$"; // these need quoting /** * Helper class to quote a attribute's value when the value is being * written to the resultant HTML document. Values set by the * put method are automatically quoted as needed. This * method is provided in case the user is dynamically constructing a new * tag to be appended with append and needs to quote some * arbitrary values. *

* The quoting algorithm is as follows:
* If the string contains double-quotes, put single quotes around it.
* If the string contains any "special" characters, put double-quotes * around it. *