*
* Removes whitespace before
*
* Leaves whitespace alone in ...
*
* Leaves whitespace alone inside "..." in tags.
*
* Normalises newlines to \n.
*
* If there is whitespace before, or after a comment or a between multiple comments it will be collapsed to a single
* space or NL. Macro comments will not remove whitespace entirely before or after. They expand to text, so that
* whitespace is significant.
*
* We emit NLs when we first see one, and avoid emitting subsequent NLs. However, we procrastinate emitting space until
* we find the end of the space string. That way we can often eliminate the spaces altogether, replacing it with an NL.
*
* @author Roedy Green
* @version 2.6 2008-02-28 optionally allow comments to be stripped out entirely. Preserve some space around
* configurable magic macro comments that expand into text such as
*
* Created by IntelliJ IDEA.
*/
enum HTMLState
{
IN_COMMENT/* inside we jump ahead when hit . Treat much like PRE */
{
HTMLState next( HTMLCharCategory category, char nextChar )
{
switch ( category )
{
case BEGIN:
case END:
case QUOTE:
case TEXT:
emit.append( nextChar );
return IN_COMMENT;
case DASH:
if ( lookAhead( 2 ).equals( "->" ) )
{
// cheat, process 2 extra chars without using state machine
charIndex += 2;
emit.append( "-->" );
// pick up where we left off as if the comment never happened.
return previousTextState;
}
else
{
emit.append( '-' );
return IN_COMMENT;
}
case IGNORE:
return IN_COMMENT;
case NL:
lineNumber++;
emit.append( '\n' );
return IN_COMMENT_DEAD_SPACE;
case SPACE:
return IN_COMMENT_COMPACTIBLE_SPACE;
default:
throw new IllegalArgumentException( "program bug: invalid category" );
}
}},
IN_COMMENT_COMPACTIBLE_SPACE/* inside spaces in a comment */
{
HTMLState next( HTMLCharCategory category, char nextChar )
{
switch ( category )
{
case BEGIN:
case END:
case QUOTE:
case TEXT:
emit.append( ' ' );
emit.append( nextChar );
return IN_COMMENT;
case IGNORE:
case SPACE:
return IN_COMMENT_COMPACTIBLE_SPACE;
case NL:
// we don't suppress NLs inside comments.
lineNumber++;
emit.append( '\n' );
return IN_COMMENT_DEAD_SPACE;
case DASH:
if ( lookAhead( 2 ).equals( "->" ) )
{
// cheat, process 2 extra chars without using state machine
charIndex += 2;
emit.append( " -->" );
// pick up where we left off as if the comment never happened.
return previousTextState;
}
else
{
emit.append( " -" );
return IN_COMMENT;
}
default:
throw new IllegalArgumentException( "program bug: invalid category" );
}
}},
IN_COMMENT_DEAD_SPACE/* inside spaces in a comment, after a newline leading on a line, will be totally deleted. */
{
HTMLState next( HTMLCharCategory category, char nextChar )
{
switch ( category )
{
case BEGIN:
case END:
case QUOTE:
case TEXT:
emit.append( nextChar );
return IN_COMMENT;
case DASH:
if ( lookAhead( 2 ).equals( "->" ) )
{
// cheat, process 2 extra chars without using state machine
charIndex += 2;
emit.append( "-->" );
// pick up where we left off as if the comment never happened.
return previousTextState;
}
else
{
emit.append( '-' );
return IN_COMMENT;
}
case IGNORE:
case NL:
case SPACE:
return IN_COMMENT_DEAD_SPACE;
default:
throw new IllegalArgumentException( "program bug: invalid category" );
}
}},
IN_DEAD_SPACE/* inside lead spaces on line of ordinary text, or after ....
Whitespace that will disappear entirely */
{
HTMLState next( HTMLCharCategory category, char nextChar )
{
switch ( category )
{
case BEGIN:
tagCategory =
// allow for / and >, < already parsed.
TagCategory.categorise( parsePartialTag( lookAhead( LONGEST_COMPRESSIBLE_TAG +
2 ) ) );
switch ( tagCategory )
{
case COMMENT:
charIndex += "!--".length();
// Will be further later incremented by 1 by charIndexLoop
// Record what we were doing so we can pick up where we left off after comment.
if ( isMacroComment() )
{
// we always keep comment, preserving any trailing whitespace.
// is no lead whitespace
emit.append( " we jump ahead when hit . We are removing this comment entirely */
{
HTMLState next( HTMLCharCategory category, char nextChar )
{
switch ( category )
{
case BEGIN:
case END:
case IGNORE:
case NL:
case QUOTE:
case SPACE:
case TEXT:
// ignore everything.
return STRIPPING_COMMENT;
case DASH:
if ( lookAhead( 2 ).equals( "->" ) )
{
// cheat, process 2 extra chars without using state machine
charIndex += 2;
// pick up where we left off as if the comment never happened.
return previousTextState;
}
else
{
return STRIPPING_COMMENT;
}
default:
throw new IllegalArgumentException( "program bug: invalid category" );
}
}};
// ------------------------------ FIELDS ------------------------------
/**
* true if want debugging output
*/
private static final boolean DEBUGGING = false;
/**
* normally true to keep comments. false to strip them out.
*/
private static boolean keepComments;
/**
* offset in big where we are processing
*/
private static int charIndex;
/**
* line number we are processing in the output file. 1-based.
*/
private static int lineNumber;
/**
* longest tag that will compress spaces either side of
*/
private static final int LONGEST_COMPRESSIBLE_TAG = "blockquote".length();
/**
* lets us remember what we were doing before the comment so we can pick up where we left off
*/
private static HTMLState previousTextState;
/**
* list of lookingAt patterns of macro-style comments that expand to text, e.g. SSI, JSP or html static macro
* comments. start looking at end of <--
*/
private static Pattern[] macroCommentPatterns;
/**
* where we accumulate the compacted output
*/
private static StringBuilder emit;
/**
* big input string we are parsing
*/
private static String big;
/**
* used in error messages to indicate where the error occurred, usually the name of the file being compacted.
*/
private static String where;
/**
* category of the most recently encountered tag
*/
private static TagCategory tagCategory;
// -------------------------- PUBLIC STATIC METHODS --------------------------
/**
* Remove excess whitespace from HTML represented by string.
*
* @param big the String to compact.
* @param where used in error messages to indicate where the error occurred, usually the name of the
* file being compacted.
* @param keepComments usually true to keep comments. false to strip them out.
* @param macroCommentPatterns when keepComments=false, these are a list of regex lookingat startsWith patterns for
* the exceptions, i.e. comments you want to keep anyway e.g. Pattern.compile (
* "\\s*macro\\s+" ) to keep html static macro comments of the form <--__macro__ or
* Pattern.compile ("#") to keep SSI comments of the form <--# These style of comments
* are macros, that expand into text, either through JSP, static macros, SSI etc.
* Further one char of whitespace will be preserved both before and after such a
* comment. With normal comments, whitespace before or after or both collapses down to a
* single whitespace char, possibly before or after the comment. Patterns are
* case-sensitive unless you use (?i) to turn on case insensitivity in your pattern.
* @return the compacted String, big itself if nothing changed.
*/
@SuppressWarnings( { "SameParameterValue" } )
public static String compactString( final String big,
final String where,
boolean keepComments,
Pattern... macroCommentPatterns )
{
HTMLState.big = big;
HTMLState.where = where;
HTMLState.keepComments = keepComments;
HTMLState.macroCommentPatterns = macroCommentPatterns;
final int length = big.length();
emit = new StringBuilder( length );
lineNumber = 1;
HTMLState state = IN_DEAD_SPACE;
previousTextState = IN_DEAD_SPACE;
// charIndex is static
for ( charIndex = 0; charIndex < length; charIndex++ )
{
final char c = big.charAt( charIndex );
final HTMLCharCategory category = HTMLCharCategory.categorise( c );
if ( DEBUGGING )
{
System.out
.println( ">>>" +
state.toString() +
" " +
tagCategory +
" [" +
c +
"] " +
category.toString() );
}
state = state.next( category, c );
}
// we don't append a final NL.
final String result = emit.toString();
emit = null;
if ( result.length() == length && result.equals( big ) )
{
// signal to caller nothing changed, also cuts RAM use in half at next GC.
return big;
}
else
{
return result;
}
}
// -------------------------- STATIC METHODS --------------------------
/**
* Check configuration and regex patterns to decide if this is a macro style comment that must be preserved even if
* other comments are stripped and whose lead and trail whitespace cannot be totally deleted.
*
* @return true if we are pointing at a macro-style comment that expands into text rather than being totally
* ignored.
*/
private static boolean isMacroComment()
{
if ( macroCommentPatterns.length == 0 )
{
return false;
}
else
{
// we have have only incremented past 3 of the 4 lead chars yet.
if ( pattern.matcher( lookIn ).lookingAt() )
{
// matched the pattern, it was a comment we keep
return true;
}
}// end for
// just an ordinary comment and we are stripping them.
return false;
}
}
/**
* look at chars ahead in the stream yet to be processed, starting at charIndex+1
*
* @param howFar how many chars you want
* @return 0 to howFar chars.
*/
private static String lookAhead( int howFar )
{
final int start = charIndex + 1;
final int end = Math.min( start + howFar, big.length() );
if ( start >= end )
{
return "";
}
else
{
return big.substring( start, end );
}
}
/**
* parse candidate tag.
*
* @param partialTag first LONGEST_COMPRESSIBLE_TAG+2 chars of the tag, possibly including trailing space or > and
* other junk, without lead <.
* @return tag with < > and trailing white space stripped e.g. dt, /dt ,!--, /blockquote
*/
private static String parsePartialTag( final String partialTag )
{
// | this stuff \n" +
" | \n" +
" sit still very still | " +
"\n" +
"
\n" +
" contents [an error occurred while processing this directive]