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); } }