public void ParsedAttribute(Tag tag, TagNamespace ns, string key, string val)
{
if (tag.Attributes.ContainsKey(key) == false)
tag.Attributes.Add(key, val);
else if (tag.Attributes.ContainsKey(ns + ":" + key) == false)
tag.Attributes.Add(ns + ":" + key, val);
}
public void ParsedOpeningTag(Tag tag)
{
//Ignore tags before root
if (current == null)
{
if (tag.SelfClosed)
{
if (tag.Name.StartsWith("?xml"))
return;
ParseError("Ignoring top level selfclosed: " + tag);
return;
}
if (document != null)
{
ParseError("Ignoring top level after first root node: " + tag);
return;
}
document = tag;
current = tag;
return;
}
current.Children.Add(tag);
if (tag.SelfClosed)
{
previous = tag;
return;
}
previous = null;
current = tag;
}
public void ParsedClosingTag(Tag tag)
{
output.ParsedClosingTag(tag);
var top = stack[stack.Count - 1];
if (top.Tag == tag)
stack.Remove(top);
}
public void ParsedClosingTag(Tag tag)
{
//Value is only null for selfclosed tags
if (current.Value == null)
current.Value = "";
previous = current;
current = current.Parent;
}
public void ParsedOpeningTag(Tag tag)
{
Writer.Write("<" + tag.Name);
foreach (var a in tag.Attributes)
Writer.Write(" " + a.Key + "=\"" + HttpUtility.HtmlEncode(a.Value) + "\"");
if (tag.SelfClosed)
Writer.Write("/");
Writer.Write(">");
}
public void ParsedClosingTag(Tag tag)
{
if (subOutput != null)
subOutput.ParsedClosingTag(tag);
if (subTag == tag)
{
subOutput = null;
subTag = null;
}
}
public void ParsedOpeningTag(Tag tag)
{
if (subOutput == null)
{
subOutput = ParseTag(tag);
if (subOutput == null)
return;
subTag = tag;
}
subOutput.ParsedOpeningTag(tag);
}
public void ParsedOpeningTag(Tag tag)
{
string id = tag.Attribute("id");
if (id != null)
tag.Attributes["id"] = ob.ObfuscateID(id);
string classes = tag.Attribute("class");
if (classes != null)
{
var cs = classes.Split(' ');
for (int n = 0; n < cs.Length; n++)
cs[n] = ob.ObfuscateClass(cs[n]);
tag.Attributes["class"] = string.Join(" ", cs);
}
output.ParsedOpeningTag(tag);
}
public void ParsedOpeningTag(Tag tag)
{
if (tag.Name == "!doctype")
{
writer.WriteLine("<!DOCTYPE html>");
return;
}
writer.Write("<" + tag.Name);
foreach (var kv in tag.Attributes)
{
writer.Write(" " + kv.Key + "=\"" + HttpUtility.HtmlEncode(kv.Value) + "\"");
}
if (tag.SelfClosed)
writer.Write("/");
writer.Write(">");
}
void GotClosingTag(Tag tag)
{
//Scan from top of stack
if (topTag == null || !topTag.HasMatchingStartTag(tag))
return; //More to skip
//Close all tags up to the closing tag
while (topTag.Name != tag.Name || topTag.Namespace != tag.Namespace)
{
output.ParseError("Missing matching close tag for <" + topTag.Name + ">");
output.ParsedClosingTag(topTag);
topTag = topTag.Parent;
}
output.ParsedClosingTag(topTag);
topTag = topTag.Parent;
parsed = pos;
}
public Tag(string ns, string name, Tag parent)
{
this.Namespace = ns;
this.Name = name;
this.Parent = parent;
this.After = ""; //After is never null
//this.Value; //Value is null in self closed tags
if (parent == null)
this.NS = new Dictionary<string, TagNamespace>();
else
this.NS = parent.NS;
//Selfclosing
if (name == null)
return; //Text "tag"
if (name == "!doctype")
SelfClosed = true;
if (name.StartsWith("?xml"))
SelfClosed = true;
}
public void ParsedOpeningTag(Tag tag)
{
//Get them before they get obfuscated
string id = tag.Attribute("id");
string cs = tag.Attribute("class");
//Ofuscation being done here
output.ParsedOpeningTag(tag);
string[] classes = cs == null ? new string[0] : cs.Split(' ');
if (id == null && classes.Length == 0)
return;
var s = new StackItem(tag);
foreach (var data in stack[stack.Count - 1].Selectors)
{
//Extract local ID
if (id != null)
s.Selectors.Add(data.CreateID(id, tag.Name));
//Extract local classes
foreach (string c in classes)
{
if (c == "")
continue;
s.Selectors.Add(data.CreateClass(c, tag.Name));
}
}
if (tag.SelfClosed)
return;
//Add to stack
if(s.Selectors.Count > 0)
stack.Add(s);
}
public void ParsedAttribute(Tag tag, TagNamespace ns, string key, string val)
{
tag.Attributes.Add(key, val);
}
static void RenderTag(Tag t, StringBuilder s)
{
s.Append("<");
s.Append(t.Name);
foreach (var a in t.Attributes)
s.Append(" " + a.Key + "=\"" + Html.Escape(a.Value) + "\"");
if (t.SelfClosed)
{
s.Append("/>");
s.Append(t.After);
return;
}
else
{
s.Append(">");
s.Append(t.Value);
}
foreach (var c in t.Children)
RenderTag(c, s);
s.Append("</" + t.Name + ">");
s.Append(t.After);
}
/// <summary>
/// Scan up the hiearchy for a matching start tag
/// </summary>
public bool HasMatchingStartTag(Tag tag)
{
if (this.Name == tag.Name && this.Namespace == tag.Namespace)
return true;
if (Parent == null)
return false;
return Parent.HasMatchingStartTag(tag);
}
public void ParsedOpeningTag(Tag tag)
{
output.ParsedOpeningTag(tag);
}
public void ParsedOpeningTag(Tag tag)
{
}
public void ParsedAttribute(Tag tag, TagNamespace ns, string key, string val)
{
if (subOutput != null)
subOutput.ParsedAttribute(tag, ns, key, val);
}
/// <summary>
/// Possibly selfclosed
/// </summary>
/// <param name="tag">Tag.</param>
public void ParsedOpeningTag(Tag tag)
{
string name = tag.Name;
switch (name)
{
case "hr":
case "br":
case "img":
case "?xml":
case "!doctype":
tag.SelfClosed = true;
break;
}
if (hidden != null)
return;
bool escaped = true;
if (whiteList.Contains(name))
escaped = false;
else if (HiddenTags.Contains(name))
return;
else if (HiddenTagsChildren.Contains(name))
{
hidden = tag;
return;
}
if (escaped)
{
writer.ParsedText("<" + tag.Name + (tag.SelfClosed ? "/" : "") + ">");
return;
}
//Image tags have a special format that links to the image without showing it
if (tag.Name == "img")
{
if (!tag.Attributes.ContainsKey("src"))
return;
//Tranform <img> to [<a href="">...</a>]
if (tag.Attributes.ContainsKey("title"))
writer.ParsedText("[" + tag.Attributes["title"] + ": ");
else
writer.ParsedText("[img: ");
var a = new Tag(null, "a", tag.Parent);
string url = tag.Attributes["src"];
a.Attributes.Add("href", url);
writer.ParsedOpeningTag(a);
writer.ParsedText(url);
writer.ParsedClosingTag(a);
writer.ParsedText("]");
return;
}
//Allowed, HTML
writer.ParsedOpeningTag(tag);
}
public void ParsedClosingTag(Tag tag)
{
writer.Write("</" + tag.Name + ">");
}
public void ParsedClosingTag(Tag tag)
{
if (hidden != null)
{
//Closing hidden tag, time to show tags again
if (hidden == tag)
hidden = null;
return;
}
string name = tag.Name;
if(blockTags.Contains(name))
writer.WriteLine();
}
public void ParsedAttribute(Tag tag, TagNamespace ns, string key, string val)
{
key = key.ToLowerInvariant();
val = HttpUtility.HtmlDecode(val);
tag.Attributes.Add(key, val);
}
/// <summary>
/// Possibly selfclosed
/// </summary>
public void ParsedOpeningTag(Tag tag)
{
string name = tag.Name;
switch (name)
{
case "hr":
case "br":
case "img":
case "?xml":
case "!doctype":
tag.SelfClosed = true;
break;
}
if (hidden != null)
return;
if (HtmlCleaner.HiddenTags.Contains(name))
return;
else if (HtmlCleaner.HiddenTagsChildren.Contains(name))
{
hidden = tag;
return;
}
if (blockTags.Contains(tag.Name) && tag.SelfClosed)
writer.WriteLine();
if (tag.Name == "a")
{
string src = tag.Attribute("src");
if (src != null)
writer.Write(" " + src + " ");
}
if (tag.Name == "img")
{
string url = tag.Attribute("src");
string alt = tag.Attribute("alt");
if (url == null)
return;
writer.Write("[" + alt + ": " + url + "]");
return;
}
}
public void ParsedAttribute(Tag tag, TagNamespace ns, string key, string val)
{
}
public void ParsedAttribute(Tag tag, TagNamespace ns, string key, string val)
{
if (string.IsNullOrWhiteSpace(val))
return;
output.ParsedAttribute(tag, ns, key, val);
}
public void ParsedClosingTag(Tag tag)
{
output.ParsedClosingTag(tag);
}
public void ParsedAttribute(Tag tag, TagNamespace ns, string key, string val)
{
key = key.ToLowerInvariant();
if (tag.Attributes.ContainsKey(key))
return;
val = HttpUtility.HtmlDecode(val);
switch (key)
{
case "href":
if (!Uri.IsWellFormedUriString(val, UriKind.Absolute))
return;
tag.Attributes.Add("href", new Uri(val).ToString());
return;
case "src":
if (tag.Name != "img")
return;
if (!Uri.IsWellFormedUriString(val, UriKind.Absolute))
return;
tag.Attributes.Add("src", new Uri(val).ToString());
return;
case "alt":
case "align":
case "border":
case "cite":
case "coords":
case "datetime":
case "download":
case "for":
case "headers":
case "height":
case "high":
case "hreflang":
case "low":
case "media":
case "min":
case "max":
case "open":
case "optimum":
case "pubdate":
case "rel":
case "reversed":
case "shape":
case "span":
case "start":
case "summary":
case "title":
case "type":
case "value":
case "width":
case "wrap":
tag.Attributes.Add(key, val);
return;
case "target":
switch (val)
{
case "_self":
case "_blank":
//case "_parent":
case "_top":
tag.Attributes.Add(key, val);
return;
}
return;
case "cols":
case "colspan":
case "rows":
case "rowspan":
//Integer values
int iv;
if (int.TryParse(val, out iv))
tag.Attributes.Add(key, iv.ToString());
return;
}
}
public void ParsedClosingTag(Tag tag)
{
}
protected abstract ITagOutput ParseTag(Tag tag);
public void ParsedClosingTag(Tag tag)
{
if (hidden != null)
{
//Closing hidden tag, time to show tags again
if (hidden == tag)
hidden = null;
return;
}
string name = tag.Name;
bool escaped = true;
if (whiteList.Contains(name))
escaped = false;
else if (HiddenTags.Contains(name))
return;
else if (HiddenTagsChildren.Contains(name))
{
Console.Error.WriteLine("Unexpected hidden closing tag: " + name);
return;
}
if (escaped)
{
writer.ParsedText("</" + tag.Name + ">");
}
else
{
writer.ParsedClosingTag(tag);
}
}
