org.w3c.tidy.Clean Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jtidy Show documentation
Show all versions of jtidy Show documentation
JTidy is a Java port of HTML Tidy, a HTML syntax checker and pretty printer. Like its non-Java cousin, JTidy can be
used as a tool for cleaning up malformed and faulty HTML. In addition, JTidy provides a DOM interface to the
document that is being processed, which effectively makes you able to use JTidy as a DOM parser for real-world HTML.
The newest version!
/*
* Java HTML Tidy - JTidy
* HTML parser and pretty printer
*
* Copyright (c) 1998-2000 World Wide Web Consortium (Massachusetts
* Institute of Technology, Institut National de Recherche en
* Informatique et en Automatique, Keio University). All Rights
* Reserved.
*
* Contributing Author(s):
*
* Dave Raggett
* Andy Quick (translation to Java)
* Gary L Peskin (Java development)
* Sami Lempinen (release management)
* Fabrizio Giustina
*
* The contributing author(s) would like to thank all those who
* helped with testing, bug fixes, and patience. This wouldn't
* have been possible without all of you.
*
* COPYRIGHT NOTICE:
*
* This software and documentation is provided "as is," and
* the copyright holders and contributing author(s) make no
* representations or warranties, express or implied, including
* but not limited to, warranties of merchantability or fitness
* for any particular purpose or that the use of the software or
* documentation will not infringe any third party patents,
* copyrights, trademarks or other rights.
*
* The copyright holders and contributing author(s) will not be
* liable for any direct, indirect, special or consequential damages
* arising out of any use of the software or documentation, even if
* advised of the possibility of such damage.
*
* Permission is hereby granted to use, copy, modify, and distribute
* this source code, or portions hereof, documentation and executables,
* for any purpose, without fee, subject to the following restrictions:
*
* 1. The origin of this source code must not be misrepresented.
* 2. Altered versions must be plainly marked as such and must
* not be misrepresented as being the original source.
* 3. This Copyright notice may not be removed or altered from any
* source or altered source distribution.
*
* The copyright holders and contributing author(s) specifically
* permit, without fee, and encourage the use of this source code
* as a component for supporting the Hypertext Markup Language in
* commercial products. If you use this source code in a product,
* acknowledgment is not required but would be appreciated.
*
*/
package org.w3c.tidy;
/**
* Clean up misuse of presentation markup. Filters from other formats such as Microsoft Word often make excessive use of
* presentation markup such as font tags, B, I, and the align attribute. By applying a set of production rules, it is
* straight forward to transform this to use CSS. Some rules replace some of the children of an element by style
* properties on the element, e.g.
*
* ...
*
.
*
* ...
*
* Such rules are applied to the element's content and then to the element itself until none of the rules more apply.
* Having applied all the rules to an element, it will have a style attribute with one or more properties. Other rules
* strip the element they apply to, replacing it by style properties on the contents, e.g.
*
*
* ...
* .
*
* ... These rules are applied to an element before processing its content and replace the current element by the first
* element in the exposed content. After applying both sets of rules, you can replace the style attribute by a class
* value and style rule in the document head. To support this, an association of styles and class names is built. A
* naive approach is to rely on string matching to test when two property lists are the same. A better approach would be
* to first sort the properties before matching.
* @author Dave Raggett [email protected]
* @author Andy Quick [email protected] (translation to Java)
* @author Fabrizio Giustina
* @version $Revision: 802 $ ($Author: fgiust $)
*/
public class Clean
{
/**
* sequential number for generated css classes.
*/
private int classNum = 1;
/**
* Tag table.
*/
private TagTable tt;
/**
* Instantiates a new Clean.
* @param tagTable tag table instance
*/
public Clean(TagTable tagTable)
{
this.tt = tagTable;
}
/**
* Insert a css style property.
* @param props StyleProp instance
* @param name property name
* @param value property value
* @return StyleProp containin the given property
*/
private StyleProp insertProperty(StyleProp props, String name, String value)
{
StyleProp first, prev, prop;
int cmp;
prev = null;
first = props;
while (props != null)
{
cmp = props.name.compareTo(name);
if (cmp == 0)
{
// this property is already defined, ignore new value
return first;
}
if (cmp > 0) // props.name > name
{
// insert before this
prop = new StyleProp(name, value, props);
if (prev != null)
{
prev.next = prop;
}
else
{
first = prop;
}
return first;
}
prev = props;
props = props.next;
}
prop = new StyleProp(name, value, null);
if (prev != null)
{
prev.next = prop;
}
else
{
first = prop;
}
return first;
}
/**
* Create sorted linked list of properties from style string.
* @param prop StyleProp
* @param style style string
* @return StyleProp with given style
*/
private StyleProp createProps(StyleProp prop, String style)
{
int nameEnd;
int valueEnd;
int valueStart = 0;
int nameStart = 0;
boolean more;
nameStart = 0;
while (nameStart < style.length())
{
while (nameStart < style.length() && style.charAt(nameStart) == ' ')
{
++nameStart;
}
nameEnd = nameStart;
while (nameEnd < style.length())
{
if (style.charAt(nameEnd) == ':')
{
valueStart = nameEnd + 1;
break;
}
++nameEnd;
}
if (nameEnd >= style.length() || style.charAt(nameEnd) != ':')
{
break;
}
while (valueStart < style.length() && style.charAt(valueStart) == ' ')
{
++valueStart;
}
valueEnd = valueStart;
more = false;
while (valueEnd < style.length())
{
if (style.charAt(valueEnd) == ';')
{
more = true;
break;
}
++valueEnd;
}
prop = insertProperty(prop, style.substring(nameStart, nameEnd), style.substring(valueStart, valueEnd));
if (more)
{
nameStart = valueEnd + 1;
continue;
}
break;
}
return prop;
}
/**
* Create a css property.
* @param props StyleProp
* @return css property as String
*/
private String createPropString(StyleProp props)
{
String style = "";
int len;
StyleProp prop;
// compute length
for (len = 0, prop = props; prop != null; prop = prop.next)
{
len += prop.name.length() + 2;
len += prop.value.length() + 2;
}
for (prop = props; prop != null; prop = prop.next)
{
style = style.concat(prop.name);
style = style.concat(": ");
style = style.concat(prop.value);
if (prop.next == null)
{
break;
}
style = style.concat("; ");
}
return style;
}
/**
* Creates a string with merged properties.
* @param style css style
* @param property css properties
* @return merged string
*/
private String addProperty(String style, String property)
{
StyleProp prop;
prop = createProps(null, style);
prop = createProps(prop, property);
style = createPropString(prop);
return style;
}
/**
* Generates a new css class name.
* @param lexer Lexer
* @param tag Tag
* @return generated css class
*/
private String gensymClass(Lexer lexer, String tag)
{
String str;
str = lexer.configuration.cssPrefix == null ? lexer.configuration.cssPrefix + this.classNum : "c"
+ this.classNum;
this.classNum++;
return str;
}
/**
* Finds a css style.
* @param lexer Lexer
* @param tag tag name
* @param properties css properties
* @return style string
*/
private String findStyle(Lexer lexer, String tag, String properties)
{
Style style;
for (style = lexer.styles; style != null; style = style.next)
{
if (style.tag.equals(tag) && style.properties.equals(properties))
{
return style.tagClass;
}
}
style = new Style(tag, gensymClass(lexer, tag), properties, lexer.styles);
lexer.styles = style;
return style.tagClass;
}
/**
* Find style attribute in node, and replace it by corresponding class attribute. Search for class in style
* dictionary otherwise gensym new class and add to dictionary. Assumes that node doesn't have a class attribute.
* @param lexer Lexer
* @param node node with a style attribute
*/
private void style2Rule(Lexer lexer, Node node)
{
AttVal styleattr, classattr;
String classname;
styleattr = node.getAttrByName("style");
if (styleattr != null)
{
classname = findStyle(lexer, node.element, styleattr.value);
classattr = node.getAttrByName("class");
// if there already is a class attribute then append class name after a space
if (classattr != null)
{
classattr.value = classattr.value + " " + classname;
node.removeAttribute(styleattr);
}
else
{
// reuse style attribute for class attribute
styleattr.attribute = "class";
styleattr.value = classname;
}
}
}
/**
* Adds a css rule for color.
* @param lexer Lexer
* @param selector css selector
* @param color color value
*/
private void addColorRule(Lexer lexer, String selector, String color)
{
if (color != null)
{
lexer.addStringLiteral(selector);
lexer.addStringLiteral(" { color: ");
lexer.addStringLiteral(color);
lexer.addStringLiteral(" }\n");
}
}
/**
* Move presentation attribs from body to style element.
*
*
* background="foo" . body { background-image: url(foo) }
* bgcolor="foo" . body { background-color: foo }
* text="foo" . body { color: foo }
* link="foo" . :link { color: foo }
* vlink="foo" . :visited { color: foo }
* alink="foo" . :active { color: foo }
*
*
* @param lexer Lexer
* @param body body node
*/
private void cleanBodyAttrs(Lexer lexer, Node body)
{
AttVal attr;
String bgurl = null;
String bgcolor = null;
String color = null;
attr = body.getAttrByName("background");
if (attr != null)
{
bgurl = attr.value;
attr.value = null;
body.removeAttribute(attr);
}
attr = body.getAttrByName("bgcolor");
if (attr != null)
{
bgcolor = attr.value;
attr.value = null;
body.removeAttribute(attr);
}
attr = body.getAttrByName("text");
if (attr != null)
{
color = attr.value;
attr.value = null;
body.removeAttribute(attr);
}
if (bgurl != null || bgcolor != null || color != null)
{
lexer.addStringLiteral(" body {\n");
if (bgurl != null)
{
lexer.addStringLiteral(" background-image: url(");
lexer.addStringLiteral(bgurl);
lexer.addStringLiteral(");\n");
}
if (bgcolor != null)
{
lexer.addStringLiteral(" background-color: ");
lexer.addStringLiteral(bgcolor);
lexer.addStringLiteral(";\n");
}
if (color != null)
{
lexer.addStringLiteral(" color: ");
lexer.addStringLiteral(color);
lexer.addStringLiteral(";\n");
}
lexer.addStringLiteral(" }\n");
}
attr = body.getAttrByName("link");
if (attr != null)
{
addColorRule(lexer, " :link", attr.value);
body.removeAttribute(attr);
}
attr = body.getAttrByName("vlink");
if (attr != null)
{
addColorRule(lexer, " :visited", attr.value);
body.removeAttribute(attr);
}
attr = body.getAttrByName("alink");
if (attr != null)
{
addColorRule(lexer, " :active", attr.value);
body.removeAttribute(attr);
}
}
/**
* Check deprecated attributes in body tag.
* @param lexer Lexer
* @param doc document root node
* @return true is the body doesn't contain deprecated attributes, false otherwise.
*/
private boolean niceBody(Lexer lexer, Node doc)
{
Node body = doc.findBody(lexer.configuration.tt);
if (body != null)
{
if (body.getAttrByName("background") != null
|| body.getAttrByName("bgcolor") != null
|| body.getAttrByName("text") != null
|| body.getAttrByName("link") != null
|| body.getAttrByName("vlink") != null
|| body.getAttrByName("alink") != null)
{
lexer.badLayout |= Report.USING_BODY;
return false;
}
}
return true;
}
/**
* Create style element using rules from dictionary.
* @param lexer Lexer
* @param doc root node
*/
private void createStyleElement(Lexer lexer, Node doc)
{
Node node, head, body;
Style style;
AttVal av;
if (lexer.styles == null && niceBody(lexer, doc))
{
return;
}
node = lexer.newNode(Node.START_TAG, null, 0, 0, "style");
node.implicit = true;
// insert type attribute
av = new AttVal(null, null, '"', "type", "text/css");
av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
node.attributes = av;
body = doc.findBody(lexer.configuration.tt);
lexer.txtstart = lexer.lexsize;
if (body != null)
{
cleanBodyAttrs(lexer, body);
}
for (style = lexer.styles; style != null; style = style.next)
{
lexer.addCharToLexer(' ');
lexer.addStringLiteral(style.tag);
lexer.addCharToLexer('.');
lexer.addStringLiteral(style.tagClass);
lexer.addCharToLexer(' ');
lexer.addCharToLexer('{');
lexer.addStringLiteral(style.properties);
lexer.addCharToLexer('}');
lexer.addCharToLexer('\n');
}
lexer.txtend = lexer.lexsize;
node.insertNodeAtEnd(lexer.newNode(Node.TEXT_NODE, lexer.lexbuf, lexer.txtstart, lexer.txtend));
// now insert style element into document head doc is root node. search its children for html node the head
// node should be first child of html node
head = doc.findHEAD(lexer.configuration.tt);
if (head != null)
{
head.insertNodeAtEnd(node);
}
}
/**
* Ensure bidirectional links are consistent.
* @param node root node
*/
private void fixNodeLinks(Node node)
{
Node child;
if (node.prev != null)
{
node.prev.next = node;
}
else
{
node.parent.content = node;
}
if (node.next != null)
{
node.next.prev = node;
}
else
{
node.parent.last = node;
}
for (child = node.content; child != null; child = child.next)
{
child.parent = node;
}
}
/**
* Used to strip child of node when the node has one and only one child.
* @param node parent node
*/
private void stripOnlyChild(Node node)
{
Node child;
child = node.content;
node.content = child.content;
node.last = child.last;
child.content = null;
for (child = node.content; child != null; child = child.next)
{
child.parent = node;
}
}
/**
* Used to strip font start and end tags.
* @param element original node
* @param pnode passed in as array to allow modification. pnode[0] will contain the final node
* @todo remove the pnode parameter and make it a return value
*/
private void discardContainer(Node element, Node[] pnode)
{
Node node;
Node parent = element.parent;
if (element.content != null)
{
element.last.next = element.next;
if (element.next != null)
{
element.next.prev = element.last;
element.last.next = element.next;
}
else
{
parent.last = element.last;
}
if (element.prev != null)
{
element.content.prev = element.prev;
element.prev.next = element.content;
}
else
{
parent.content = element.content;
}
for (node = element.content; node != null; node = node.next)
{
node.parent = parent;
}
pnode[0] = element.content;
}
else
{
if (element.next != null)
{
element.next.prev = element.prev;
}
else
{
parent.last = element.prev;
}
if (element.prev != null)
{
element.prev.next = element.next;
}
else
{
parent.content = element.next;
}
pnode[0] = element.next;
}
element.next = null;
element.content = null;
}
/**
* Add style property to element, creating style attribute as needed and adding ; delimiter.
* @param node node
* @param property property added to node
*/
private void addStyleProperty(Node node, String property)
{
AttVal av;
for (av = node.attributes; av != null; av = av.next)
{
if (av.attribute.equals("style"))
{
break;
}
}
// if style attribute already exists then insert property
if (av != null)
{
String s;
s = addProperty(av.value, property);
av.value = s;
}
else
{
// else create new style attribute
av = new AttVal(node.attributes, null, '"', "style", property);
av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
node.attributes = av;
}
}
/**
* Create new string that consists of the combined style properties in s1 and s2. To merge property lists, we build
* a linked list of property/values and insert properties into the list in order, merging values for the same
* property name.
* @param s1 first property
* @param s2 second property
* @return merged properties
*/
private String mergeProperties(String s1, String s2)
{
String s;
StyleProp prop;
prop = createProps(null, s1);
prop = createProps(prop, s2);
s = createPropString(prop);
return s;
}
/**
* Merge class attributes from 2 nodes.
* @param node Node
* @param child Child node
*/
private void mergeClasses(Node node, Node child)
{
AttVal av;
String s1, s2, names;
for (s2 = null, av = child.attributes; av != null; av = av.next)
{
if ("class".equals(av.attribute))
{
s2 = av.value;
break;
}
}
for (s1 = null, av = node.attributes; av != null; av = av.next)
{
if ("class".equals(av.attribute))
{
s1 = av.value;
break;
}
}
if (s1 != null)
{
if (s2 != null) // merge class names from both
{
names = s1 + ' ' + s2;
av.value = names;
}
}
else if (s2 != null) // copy class names from child
{
av = new AttVal(node.attributes, null, '"', "class", s2);
av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
node.attributes = av;
}
}
/**
* Merge style from 2 nodes.
* @param node Node
* @param child Child node
*/
private void mergeStyles(Node node, Node child)
{
AttVal av;
String s1, s2, style;
// the child may have a class attribute used for attaching styles, if so the class name needs to be copied to
// node's class
mergeClasses(node, child);
for (s2 = null, av = child.attributes; av != null; av = av.next)
{
if (av.attribute.equals("style"))
{
s2 = av.value;
break;
}
}
for (s1 = null, av = node.attributes; av != null; av = av.next)
{
if (av.attribute.equals("style"))
{
s1 = av.value;
break;
}
}
if (s1 != null)
{
if (s2 != null) // merge styles from both
{
style = mergeProperties(s1, s2);
av.value = style;
}
}
else if (s2 != null) // copy style of child
{
av = new AttVal(node.attributes, null, '"', "style", s2);
av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
node.attributes = av;
}
}
/**
* Map a % font size to a named font size.
* @param size size in %
* @return font size name
*/
private String fontSize2Name(String size)
{
String[] sizes = {"60%", "70%", "80%", null, "120%", "150%", "200%"};
String buf;
if (size.length() > 0 && '0' <= size.charAt(0) && size.charAt(0) <= '6')
{
int n = size.charAt(0) - '0';
return sizes[n];
}
if (size.length() > 0 && size.charAt(0) == '-')
{
if (size.length() > 1 && '0' <= size.charAt(1) && size.charAt(1) <= '6')
{
int n = size.charAt(1) - '0';
double x;
for (x = 1.0; n > 0; --n)
{
x *= 0.8;
}
x *= 100.0;
buf = "" + (int) x + "%";
return buf;
}
return "smaller"; /* "70%"; */
}
if (size.length() > 1 && '0' <= size.charAt(1) && size.charAt(1) <= '6')
{
int n = size.charAt(1) - '0';
double x;
for (x = 1.0; n > 0; --n)
{
x *= 1.2;
}
x *= 100.0;
buf = "" + (int) x + "%";
return buf;
}
return "larger"; /* "140%" */
}
/**
* Adds a font-family style.
* @param node Node
* @param face font face
*/
private void addFontFace(Node node, String face)
{
addStyleProperty(node, "font-family: " + face);
}
/**
* Adds a font size style.
* @param node Node
* @param size font size
*/
private void addFontSize(Node node, String size)
{
if (size == null)
{
return;
}
if ("6".equals(size) && node.tag == this.tt.tagP)
{
node.element = "h1";
this.tt.findTag(node);
return;
}
if ("5".equals(size) && node.tag == this.tt.tagP)
{
node.element = "h2";
this.tt.findTag(node);
return;
}
if ("4".equals(size) && node.tag == this.tt.tagP)
{
node.element = "h3";
this.tt.findTag(node);
return;
}
String value = fontSize2Name(size);
if (value != null)
{
addStyleProperty(node, "font-size: " + value);
}
}
/**
* Adds a font color style.
* @param node Node
* @param color color value
*/
private void addFontColor(Node node, String color)
{
addStyleProperty(node, "color: " + color);
}
/**
* Adds an align style.
* @param node Node
* @param align align value
*/
private void addAlign(Node node, String align)
{
// force alignment value to lower case
addStyleProperty(node, "text-align: " + align.toLowerCase());
}
/**
* Add style properties to node corresponding to the font face, size and color attributes.
* @param node font tag
* @param av attribute list for node
*/
private void addFontStyles(Node node, AttVal av)
{
while (av != null)
{
if (av.attribute.equals("face"))
{
addFontFace(node, av.value);
}
else if (av.attribute.equals("size"))
{
addFontSize(node, av.value);
}
else if (av.attribute.equals("color"))
{
addFontColor(node, av.value);
}
av = av.next;
}
}
/**
* Symptom: <p align=center>. Action: <p style="text-align: center">.
* @param lexer Lexer
* @param node node with center attribute. Will be modified to use css style.
*/
private void textAlign(Lexer lexer, Node node)
{
AttVal av, prev;
prev = null;
for (av = node.attributes; av != null; av = av.next)
{
if (av.attribute.equals("align"))
{
if (prev != null)
{
prev.next = av.next;
}
else
{
node.attributes = av.next;
}
if (av.value != null)
{
addAlign(node, av.value);
}
break;
}
prev = av;
}
}
/**
* Symptom: <dir><li> where <li> is only child. Action: coerce
* <dir> <li> to <div> with indent. The clean up rules use the pnode argument
* to return the next node when the original node has been deleted.
* @param lexer Lexer
* @param node dir tag
* @return true if a dir tag has been coerced to a div
*/
private boolean dir2Div(Lexer lexer, Node node)
{
Node child;
if (node.tag == this.tt.tagDir || node.tag == this.tt.tagUl || node.tag == this.tt.tagOl)
{
child = node.content;
if (child == null)
{
return false;
}
// check child has no peers
if (child.next != null)
{
return false;
}
if (child.tag != this.tt.tagLi)
{
return false;
}
if (!child.implicit)
{
return false;
}
// coerce dir to div
node.tag = this.tt.tagDiv;
node.element = "div";
addStyleProperty(node, "margin-left: 2em");
stripOnlyChild(node);
return true;
}
return false;
}
/**
* Symptom:
*
*
* <center>
* .
*
* Action: replace <center> by <div style="text-align: center">
*
* @param lexer Lexer
* @param node center tag
* @param pnode pnode[0] is the same as node, passed in as an array to allow modification
* @return true if a center tag has been replaced by a div
*/
private boolean center2Div(Lexer lexer, Node node, Node[] pnode)
{
if (node.tag == this.tt.tagCenter)
{
if (lexer.configuration.dropFontTags)
{
if (node.content != null)
{
Node last = node.last;
Node parent = node.parent;
discardContainer(node, pnode);
node = lexer.inferredTag("br");
if (last.next != null)
{
last.next.prev = node;
}
node.next = last.next;
last.next = node;
node.prev = last;
if (parent.last == last)
{
parent.last = node;
}
node.parent = parent;
}
else
{
Node prev = node.prev;
Node next = node.next;
Node parent = node.parent;
discardContainer(node, pnode);
node = lexer.inferredTag("br");
node.next = next;
node.prev = prev;
node.parent = parent;
if (next != null)
{
next.prev = node;
}
else
{
parent.last = node;
}
if (prev != null)
{
prev.next = node;
}
else
{
parent.content = node;
}
}
return true;
}
node.tag = this.tt.tagDiv;
node.element = "div";
addStyleProperty(node, "text-align: center");
return true;
}
return false;
}
/**
* Symptom: <div><div>...</div></div> Action: merge the two divs. This is useful after
* nested <dir>s used by Word for indenting have been converted to <div>s.
* @param lexer Lexer
* @param node first div
* @return true if the divs have been merged
*/
private boolean mergeDivs(Lexer lexer, Node node)
{
Node child;
if (node.tag != this.tt.tagDiv)
{
return false;
}
child = node.content;
if (child == null)
{
return false;
}
if (child.tag != this.tt.tagDiv)
{
return false;
}
if (child.next != null)
{
return false;
}
mergeStyles(node, child);
stripOnlyChild(node);
return true;
}
/**
* Symptom:
*
* -
*
* ...
*
*
*
* Action: discard outer list.
* @param lexer Lexer
* @param node Node
* @param pnode passed in as array to allow modifications.
* @return true if nested lists have been found and replaced
*/
private boolean nestedList(Lexer lexer, Node node, Node[] pnode)
{
Node child, list;
if (node.tag == this.tt.tagUl || node.tag == this.tt.tagOl)
{
child = node.content;
if (child == null)
{
return false;
}
// check child has no peers
if (child.next != null)
{
return false;
}
list = child.content;
if (list == null)
{
return false;
}
if (list.tag != node.tag)
{
return false;
}
pnode[0] = list; // Set node to resume iteration
// move inner list node into position of outer node
list.prev = node.prev;
list.next = node.next;
list.parent = node.parent;
fixNodeLinks(list);
// get rid of outer ul and its li
// XXX: Are we leaking the child node? -creitzel 7 Jun, 01
child.content = null;
node.content = null;
node.next = null;
node = null;
// If prev node was a list the chances are this node should be appended to that list. Word has no way of
// recognizing nested lists and just uses indents
if (list.prev != null)
{
if (list.prev.tag == this.tt.tagUl || list.prev.tag == this.tt.tagOl)
{
node = list;
list = node.prev;
list.next = node.next;
if (list.next != null)
{
list.next.prev = list;
}
child = list.last; /* */
node.parent = child;
node.next = null;
node.prev = child.last;
fixNodeLinks(node);
cleanNode(lexer, node);
}
}
return true;
}
return false;
}
/**
* Symptom: the only child of a block-level element is a presentation element such as B, I or FONT. Action: add
* style "font-weight: bold" to the block and strip the <b>element, leaving its children. example:
*
*
* <p>
* <b><font face="Arial" size="6">Draft Recommended Practice</font></b>
* </p>
*
*
* becomes:
*
*
* <p style="font-weight: bold; font-family: Arial; font-size: 6">
* Draft Recommended Practice
* </p>
*
*
*
* This code also replaces the align attribute by a style attribute. However, to avoid CSS problems with Navigator
* 4, this isn't done for the elements: caption, tr and table
*
* @param lexer Lexer
* @param node parent node
* @return true if the child node has been removed
*/
private boolean blockStyle(Lexer lexer, Node node)
{
Node child;
if ((node.tag.model & (Dict.CM_BLOCK | Dict.CM_LIST | Dict.CM_DEFLIST | Dict.CM_TABLE)) != 0)
{
if (node.tag != this.tt.tagTable && node.tag != this.tt.tagTr && node.tag != this.tt.tagLi)
{
// check for align attribute
if (node.tag != this.tt.tagCaption)
{
textAlign(lexer, node);
}
child = node.content;
if (child == null)
{
return false;
}
// check child has no peers
if (child.next != null)
{
return false;
}
if (child.tag == this.tt.tagB)
{
mergeStyles(node, child);
addStyleProperty(node, "font-weight: bold");
stripOnlyChild(node);
return true;
}
if (child.tag == this.tt.tagI)
{
mergeStyles(node, child);
addStyleProperty(node, "font-style: italic");
stripOnlyChild(node);
return true;
}
if (child.tag == this.tt.tagFont)
{
mergeStyles(node, child);
addFontStyles(node, child.attributes);
stripOnlyChild(node);
return true;
}
}
}
return false;
}
/**
* If the node has only one b, i, or font child remove the child node and add the appropriate style attributes to
* parent.
* @param lexer Lexer
* @param node parent node
* @param pnode passed as an array to allow modifications
* @return true if child node has been stripped, replaced by style attributes.
*/
private boolean inlineStyle(Lexer lexer, Node node, Node[] pnode)
{
Node child;
if (node.tag != this.tt.tagFont && (node.tag.model & (Dict.CM_INLINE | Dict.CM_ROW)) != 0)
{
child = node.content;
if (child == null)
{
return false;
}
// check child has no peers
if (child.next != null)
{
return false;
}
if (child.tag == this.tt.tagB && lexer.configuration.logicalEmphasis)
{
mergeStyles(node, child);
addStyleProperty(node, "font-weight: bold");
stripOnlyChild(node);
return true;
}
if (child.tag == this.tt.tagI && lexer.configuration.logicalEmphasis)
{
mergeStyles(node, child);
addStyleProperty(node, "font-style: italic");
stripOnlyChild(node);
return true;
}
if (child.tag == this.tt.tagFont)
{
mergeStyles(node, child);
addFontStyles(node, child.attributes);
stripOnlyChild(node);
return true;
}
}
return false;
}
/**
* Replace font elements by span elements, deleting the font element's attributes and replacing them by a single
* style attribute.
* @param lexer Lexer
* @param node font tag
* @param pnode passed as an array to allow modifications
* @return true if a font tag has been dropped and replaced by style attributes
*/
private boolean font2Span(Lexer lexer, Node node, Node[] pnode)
{
AttVal av, style, next;
if (node.tag == this.tt.tagFont)
{
if (lexer.configuration.dropFontTags)
{
discardContainer(node, pnode);
return false;
}
// if FONT is only child of parent element then leave alone
if (node.parent.content == node && node.next == null)
{
return false;
}
addFontStyles(node, node.attributes);
// extract style attribute and free the rest
av = node.attributes;
style = null;
while (av != null)
{
next = av.next;
if (av.attribute.equals("style"))
{
av.next = null;
style = av;
}
av = next;
}
node.attributes = style;
node.tag = this.tt.tagSpan;
node.element = "span";
return true;
}
return false;
}
/**
* Applies all matching rules to a node.
* @param lexer Lexer
* @param node original node
* @return cleaned up node
*/
private Node cleanNode(Lexer lexer, Node node)
{
Node next = null;
Node[] o = new Node[1];
boolean b = false;
for (next = node; node != null && node.isElement(); node = next)
{
o[0] = next;
b = dir2Div(lexer, node);
next = o[0];
if (b)
{
continue;
}
// Special case: true result means that arg node and its parent no longer exist.
// So we must jump back up the CreateStyleProperties() call stack until we have a valid node reference.
b = nestedList(lexer, node, o);
next = o[0];
if (b)
{
return next;
}
b = center2Div(lexer, node, o);
next = o[0];
if (b)
{
continue;
}
b = mergeDivs(lexer, node);
next = o[0];
if (b)
{
continue;
}
b = blockStyle(lexer, node);
next = o[0];
if (b)
{
continue;
}
b = inlineStyle(lexer, node, o);
next = o[0];
if (b)
{
continue;
}
b = font2Span(lexer, node, o);
next = o[0];
if (b)
{
continue;
}
break;
}
return next;
}
/**
* Special case: if the current node is destroyed by CleanNode() lower in the tree, this node and its parent no
* longer exist. So we must jump back up the CreateStyleProperties() call stack until we have a valid node
* reference.
* @param lexer Lexer
* @param node Node
* @param prepl passed in as array to allow modifications
* @return cleaned Node
*/
private Node createStyleProperties(Lexer lexer, Node node, Node[] prepl)
{
Node child = node.content;
if (child != null)
{
Node[] repl = new Node[1];
repl[0] = node;
while (child != null)
{
child = createStyleProperties(lexer, child, repl);
if (repl[0] != node)
{
return repl[0];
}
if (child != null)
{
child = child.next;
}
}
}
return cleanNode(lexer, node);
}
/**
* Find style attribute in node content, and replace it by corresponding class attribute.
* @param lexer Lexer
* @param node parent node
*/
private void defineStyleRules(Lexer lexer, Node node)
{
Node child;
if (node.content != null)
{
child = node.content;
while (child != null)
{
defineStyleRules(lexer, child);
child = child.next;
}
}
style2Rule(lexer, node);
}
/**
* Clean an html tree.
* @param lexer Lexer
* @param doc root node
*/
public void cleanTree(Lexer lexer, Node doc)
{
Node[] repl = new Node[1];
repl[0] = doc;
doc = createStyleProperties(lexer, doc, repl);
if (!lexer.configuration.makeClean)
{
defineStyleRules(lexer, doc);
createStyleElement(lexer, doc);
}
}
/**
* simplifies ... ... etc.
* @param node root Node
*/
public void nestedEmphasis(Node node)
{
Node[] o = new Node[1];
Node next;
while (node != null)
{
next = node.next;
if ((node.tag == this.tt.tagB || node.tag == this.tt.tagI)
&& node.parent != null
&& node.parent.tag == node.tag)
{
// strip redundant inner element
o[0] = next;
discardContainer(node, o);
next = o[0];
node = next;
continue;
}
if (node.content != null)
{
nestedEmphasis(node.content);
}
node = next;
}
}
/**
* Replace i by em and b by strong.
* @param node root Node
*/
public void emFromI(Node node)
{
while (node != null)
{
if (node.tag == this.tt.tagI)
{
node.element = this.tt.tagEm.name;
node.tag = this.tt.tagEm;
}
else if (node.tag == this.tt.tagB)
{
node.element = this.tt.tagStrong.name;
node.tag = this.tt.tagStrong;
}
if (node.content != null)
{
emFromI(node.content);
}
node = node.next;
}
}
/**
* Some people use dir or ul without an li to indent the content. The pattern to look for is a list with a single
* implicit li. This is recursively replaced by an implicit blockquote.
* @param node root Node
*/
public void list2BQ(Node node)
{
while (node != null)
{
if (node.content != null)
{
list2BQ(node.content);
}
if (node.tag != null
&& node.tag.getParser() == ParserImpl.LIST
&& node.hasOneChild()
&& node.content.implicit)
{
stripOnlyChild(node);
node.element = this.tt.tagBlockquote.name;
node.tag = this.tt.tagBlockquote;
node.implicit = true;
}
node = node.next;
}
}
/**
* Replace implicit blockquote by div with an indent taking care to reduce nested blockquotes to a single div with
* the indent set to match the nesting depth.
* @param node root Node
*/
public void bQ2Div(Node node)
{
int indent;
String indentBuf;
AttVal attval;
while (node != null)
{
if (node.tag == this.tt.tagBlockquote && node.implicit)
{
indent = 1;
while (node.hasOneChild() && node.content.tag == this.tt.tagBlockquote && node.implicit)
{
++indent;
stripOnlyChild(node);
}
if (node.content != null)
{
bQ2Div(node.content);
}
indentBuf = "margin-left: " + (new Integer(2 * indent)).toString() + "em";
node.element = this.tt.tagDiv.name;
node.tag = this.tt.tagDiv;
attval = node.getAttrByName("style");
if (attval != null && attval.value != null)
{
attval.value = indentBuf + "; " + attval.value;
}
else
{
node.addAttribute("style", indentBuf);
}
}
else if (node.content != null)
{
bQ2Div(node.content);
}
node = node.next;
}
}
/**
* Find the enclosing table cell for the given node.
* @param node Node
* @return enclosing cell node
*/
Node findEnclosingCell(Node node)
{
Node check;
for (check = node; check != null; check = check.parent)
{
if (check.tag == tt.tagTd)
{
return check;
}
}
return null;
}
/**
* node is <![if ...]> prune up to <![endif]>.
* @param lexer Lexer
* @param node Node
* @return cleaned up Node
*/
public Node pruneSection(Lexer lexer, Node node)
{
for (;;)
{
// FG: commented out - don't add to empty cells
// if ((Lexer.getString(node.textarray, node.start, 21)).equals("if !supportEmptyParas"))
// {
// Node cell = findEnclosingCell(node);
// if (cell != null)
// {
// // Need to put into cell so it doesn't look weird
// char onesixty[] = {(char) 160, (char) 0};
// Node nbsp = lexer.newLiteralTextNode(lexer, onesixty);
// Node.insertNodeBeforeElement(node, nbsp);
// }
// }
// discard node and returns next
node = Node.discardElement(node);
if (node == null)
{
return null;
}
if (node.type == Node.SECTION_TAG)
{
if ((TidyUtils.getString(node.textarray, node.start, 2)).equals("if"))
{
node = pruneSection(lexer, node);
continue;
}
if ((TidyUtils.getString(node.textarray, node.start, 5)).equals("endif"))
{
node = Node.discardElement(node);
break;
}
}
}
return node;
}
/**
* Drop if/endif sections inserted by word2000.
* @param lexer Lexer
* @param node Node root node
*/
public void dropSections(Lexer lexer, Node node)
{
while (node != null)
{
if (node.type == Node.SECTION_TAG)
{
// prune up to matching endif
if ((TidyUtils.getString(node.textarray, node.start, 2)).equals("if")
&& (!(TidyUtils.getString(node.textarray, node.start, 7)).equals("if !vml"))) // #444394 - fix 13
// Sep 01
{
node = pruneSection(lexer, node);
continue;
}
// discard others as well
node = Node.discardElement(node);
continue;
}
if (node.content != null)
{
dropSections(lexer, node.content);
}
node = node.next;
}
}
/**
* Remove word2000 attributes from node.
* @param node node to cleanup
*/
public void purgeWord2000Attributes(Node node)
{
AttVal attr = null;
AttVal next = null;
AttVal prev = null;
for (attr = node.attributes; attr != null; attr = next)
{
next = attr.next;
// special check for class="Code" denoting pre text
// Pass thru user defined styles as HTML class names
if (attr.attribute != null && attr.value != null && attr.attribute.equals("class"))
{
if (attr.value.equals("Code") || !attr.value.startsWith("Mso"))
{
prev = attr;
continue;
}
}
if (attr.attribute != null
&& (attr.attribute.equals("class")
|| attr.attribute.equals("style")
|| attr.attribute.equals("lang")
|| attr.attribute.startsWith("x:") || ((attr.attribute.equals("height") || attr.attribute
.equals("width")) && //
(node.tag == this.tt.tagTd || node.tag == this.tt.tagTr || node.tag == this.tt.tagTh))))
{
if (prev != null)
{
prev.next = next;
}
else
{
node.attributes = next;
}
}
else
{
prev = attr;
}
}
}
/**
* Word2000 uses span excessively, so we strip span out.
* @param lexer Lexer
* @param span Node span
* @return cleaned node
*/
public Node stripSpan(Lexer lexer, Node span)
{
Node node;
Node prev = null;
Node content;
// deal with span elements that have content by splicing the content in place of the span after having
// processed it
cleanWord2000(lexer, span.content);
content = span.content;
if (span.prev != null)
{
prev = span.prev;
}
else if (content != null)
{
node = content;
content = content.next;
node.removeNode();
Node.insertNodeBeforeElement(span, node);
prev = node;
}
while (content != null)
{
node = content;
content = content.next;
node.removeNode();
prev.insertNodeAfterElement(node);
prev = node;
}
if (span.next == null)
{
span.parent.last = prev;
}
node = span.next;
span.content = null;
Node.discardElement(span);
return node;
}
/**
* Map non-breaking spaces to regular spaces.
* @param lexer Lexer
* @param node Node
*/
private void normalizeSpaces(Lexer lexer, Node node)
{
while (node != null)
{
if (node.content != null)
{
normalizeSpaces(lexer, node.content);
}
if (node.type == Node.TEXT_NODE)
{
int i;
int[] c = new int[1];
int p = node.start;
for (i = node.start; i < node.end; ++i)
{
c[0] = node.textarray[i];
// look for UTF-8 multibyte character
if (c[0] > 0x7F)
{
i += PPrint.getUTF8(node.textarray, i, c);
}
if (c[0] == 160)
{
c[0] = ' ';
}
p = PPrint.putUTF8(node.textarray, p, c[0]);
}
}
node = node.next;
}
}
/**
* Used to hunt for hidden preformatted sections.
* @param node checked node
* @return true if the node has a "margin-top: 0" or "margin-bottom: 0" style
*/
boolean noMargins(Node node)
{
AttVal attval = node.getAttrByName("style");
if (attval == null || attval.value == null)
{
return false;
}
// search for substring "margin-top: 0"
if (attval.value.indexOf("margin-top: 0") == -1)
{
return false;
}
// search for substring "margin-top: 0"
if (attval.value.indexOf("margin-bottom: 0") == -1)
{
return false;
}
return true;
}
/**
* Does element have a single space as its content?
* @param lexer Lexer
* @param node checked node
* @return true if the element has a single space as its content
*/
boolean singleSpace(Lexer lexer, Node node)
{
if (node.content != null)
{
node = node.content;
if (node.next != null)
{
return false;
}
if (node.type != Node.TEXT_NODE)
{
return false;
}
if (((node.end - node.start) == 1) && lexer.lexbuf[node.start] == ' ')
{
return true;
}
if ((node.end - node.start) == 2)
{
int[] c = new int[1];
PPrint.getUTF8(lexer.lexbuf, node.start, c);
if (c[0] == 160)
{
return true;
}
}
}
return false;
}
/**
* This is a major clean up to strip out all the extra stuff you get when you save as web page from Word 2000. It
* doesn't yet know what to do with VML tags, but these will appear as errors unless you declare them as new tags,
* such as o:p which needs to be declared as inline.
* @param lexer Lexer
* @param node node to clean up
*/
public void cleanWord2000(Lexer lexer, Node node)
{
// used to a list from a sequence of bulletted p's
Node list = null;
while (node != null)
{
// get rid of Word's xmlns attributes
if (node.tag == tt.tagHtml)
{
// check that it's a Word 2000 document
if ((node.getAttrByName("xmlns:o") == null))
{
return;
}
lexer.configuration.tt.freeAttrs(node);
}
// fix up preformatted sections by looking for a sequence of paragraphs with zero top/bottom margin
if (node.tag == tt.tagP)
{
if (noMargins(node))
{
Node pre;
Node next;
Node.coerceNode(lexer, node, tt.tagPre);
purgeWord2000Attributes(node);
if (node.content != null)
{
cleanWord2000(lexer, node.content);
}
pre = node;
node = node.next;
// continue to strip p's
while (node.tag == tt.tagP && noMargins(node))
{
next = node.next;
node.removeNode();
pre.insertNodeAtEnd(lexer.newLineNode());
pre.insertNodeAtEnd(node);
stripSpan(lexer, node);
node = next;
}
if (node == null)
{
break;
}
}
}
if (node.tag != null && TidyUtils.toBoolean(node.tag.model & Dict.CM_BLOCK) && singleSpace(lexer, node))
{
node = stripSpan(lexer, node);
continue;
}
// discard Word's style verbiage
if (node.tag == this.tt.tagStyle || node.tag == this.tt.tagMeta || node.type == Node.COMMENT_TAG)
{
node = Node.discardElement(node);
continue;
}
// strip out all span and font tags Word scatters so liberally!
if (node.tag == this.tt.tagSpan || node.tag == this.tt.tagFont)
{
node = stripSpan(lexer, node);
continue;
}
if (node.tag == this.tt.tagLink)
{
AttVal attr = node.getAttrByName("rel");
if (attr != null && attr.value != null && attr.value.equals("File-List"))
{
node = Node.discardElement(node);
continue;
}
}
// discard empty paragraphs
if (node.content == null && node.tag == this.tt.tagP)
{
node = Node.discardElement(node);
continue;
}
if (node.tag == this.tt.tagP)
{
AttVal attr = node.getAttrByName("class");
AttVal atrStyle = node.getAttrByName("style");
// (JES) Sometimes Word marks a list item with the following hokie syntax
// to
...
// map to
...
if (attr != null
&& attr.value != null
&& ((attr.value.equals("MsoListBullet") || attr.value.equals("MsoListNumber")) //
|| (atrStyle != null && (atrStyle.value.indexOf("mso-list:") != -1)))) // 463066 - fix by Joel
// Shafer 19 Sep 01
{
Dict listType = tt.tagUl;
if (attr.value.equals("MsoListNumber"))
{
listType = tt.tagOl;
}
Node.coerceNode(lexer, node, this.tt.tagLi);
if (list == null || list.tag != listType)
{
list = lexer.inferredTag(listType.name);
Node.insertNodeBeforeElement(node, list);
}
purgeWord2000Attributes(node);
if (node.content != null)
{
cleanWord2000(lexer, node.content);
}
// remove node and append to contents of list
node.removeNode();
list.insertNodeAtEnd(node);
node = list;
}
// map sequence of to
...
else if (attr != null && attr.value != null && attr.value.equals("Code"))
{
Node br = lexer.newLineNode();
normalizeSpaces(lexer, node);
if (list == null || list.tag != this.tt.tagPre)
{
list = lexer.inferredTag("pre");
Node.insertNodeBeforeElement(node, list);
}
// remove node and append to contents of list
node.removeNode();
list.insertNodeAtEnd(node);
stripSpan(lexer, node);
list.insertNodeAtEnd(br);
node = list.next;
}
else
{
list = null;
}
}
else
{
list = null;
}
// strip out style and class attributes
if (node.type == Node.START_TAG || node.type == Node.START_END_TAG)
{
purgeWord2000Attributes(node);
}
if (node.content != null)
{
cleanWord2000(lexer, node.content);
}
node = node.next;
}
}
/**
* Check if the current document is a converted Word document.
* @param root root Node
* @return true if the document has been geenrated by Microsoft Word.
*/
public boolean isWord2000(Node root)
{
AttVal attval;
Node node;
Node head;
Node html = root.findHTML(this.tt);
if (html != null && html.getAttrByName("xmlns:o") != null)
{
return true;
}
// search for
head = root.findHEAD(tt);
if (head != null)
{
for (node = head.content; node != null; node = node.next)
{
if (node.tag != tt.tagMeta)
{
continue;
}
attval = node.getAttrByName("name");
if (attval == null || attval.value == null)
{
continue;
}
if (!"generator".equals(attval.value))
{
continue;
}
attval = node.getAttrByName("content");
if (attval == null || attval.value == null)
{
continue;
}
if (attval.value.indexOf("Microsoft") != -1)
{
return true;
}
}
}
return false;
}
/**
* Where appropriate move object elements from head to body.
* @param lexer Lexer
* @param html html node
*/
static void bumpObject(Lexer lexer, Node html)
{
if (html == null)
{
return;
}
Node node, next, head = null, body = null;
TagTable tt = lexer.configuration.tt;
for (node = html.content; node != null; node = node.next)
{
if (node.tag == tt.tagHead)
{
head = node;
}
if (node.tag == tt.tagBody)
{
body = node;
}
}
if (head != null && body != null)
{
for (node = head.content; node != null; node = next)
{
next = node.next;
if (node.tag == tt.tagObject)
{
Node child;
boolean bump = false;
for (child = node.content; child != null; child = child.next)
{
// bump to body unless content is param
if ((child.type == Node.TEXT_NODE && !node.isBlank(lexer)) || child.tag != tt.tagParam)
{
bump = true;
break;
}
}
if (bump)
{
node.removeNode();
body.insertNodeAtStart(node);
}
}
}
}
}
}