/// <summary>
/// Adds a top-level rule for the element.
/// </summary>
/// <param name="builder">The selector function.</param>
public IRuleAppender Treat(Func <IRuleSelector, IRuleBuilder> builder)
{
Precondition.Require(builder, () => Error.ArgumentNull("inner"));
IRuleBuilder rule = builder(this);
HtmlElementRule elem = (rule as HtmlElementRule);
HtmlAttributeRule attr = (rule as HtmlAttributeRule);
HtmlElementRuleCollection ec = (rule as HtmlElementRuleCollection);
HtmlAttributeRuleCollection ac = (rule as HtmlAttributeRuleCollection);
if (elem != null)
{
AddElementRule(elem);
}
else if (ec != null)
{
AddElementRules(ec);
}
else if (attr != null)
{
AddAttributeRule(attr);
}
else if (ac != null)
{
AddAttributeRules(ac);
}
else
{
throw Error.UnsupportedElementRule("builder");
}
return(this);
}
public HtmlElementContext(HtmlElementRule rule,
IValueSet parameters)
: base(parameters)
{
Precondition.Require(rule, () => Error.ArgumentNull("rule"));
_rule = rule;
}
protected HtmlElementResult ConvertElement(HtmlElementRule parent, XmlElement element)
{
Precondition.Require(element, () => Error.ArgumentNull("element"));
HtmlElementRule rule = GetElementRule(parent, element.LocalName);
HtmlElementContext context = new HtmlElementContext(rule.Clone(), Parameters);
if (rule.HasConverter)
{
element = rule.Converter(context, element);
if (element == null)
{
return(null);
}
if (!MatchName(element, context.Rule))
{
rule = GetElementRule(parent, element.LocalName);
}
if ((rule.Options & HtmlElementOptions.Generated) == HtmlElementOptions.Generated)
{
rule = rule.Clone();
rule.Options |= HtmlElementOptions.Allowed;
}
}
return(new HtmlElementResult(element, rule));
}
protected virtual XmlAttribute WriteAttribute(HtmlElementRule element, XmlAttribute attribute)
{
HtmlAttributeResult result = ConvertAttribute(element, attribute);
if (result == null)
{
return(null);
}
string value = result.Attribute.Value;
if ((result.Rule.Options & HtmlAttributeOptions.Allowed) == HtmlAttributeOptions.Allowed)
{
if ((result.Rule.Options & HtmlAttributeOptions.Default) == HtmlAttributeOptions.Default &&
String.IsNullOrEmpty(value))
{
value = result.Rule.DefaultValue;
}
if (result.Rule.ValidateValue(value))
{
_writer.WriteAttributeString(result.Attribute.LocalName, value);
return(result.Attribute);
}
}
return(null);
}
protected HtmlAttributeResult ConvertAttribute(HtmlElementRule element, XmlAttribute attribute)
{
HtmlAttributeRule attrRule = GetAttributeRule(element, attribute.LocalName);
HtmlAttributeContext context = new HtmlAttributeContext(attrRule.Clone(), Parameters);
if (attrRule.HasConverter)
{
attribute = attrRule.Converter(context, attribute);
if (attribute == null)
{
return(null);
}
if (!MatchName(attribute, attrRule))
{
attrRule = GetAttributeRule(element, attribute.LocalName);
}
if ((attrRule.Options & HtmlAttributeOptions.Generated) == HtmlAttributeOptions.Generated)
{
attrRule = attrRule.Clone();
attrRule.Options |= HtmlAttributeOptions.Allowed;
}
}
return(new HtmlAttributeResult(attribute, attrRule));
}
public HtmlElementContext(HtmlElementRule rule,
IValueSet parameters)
: base(parameters)
{
Precondition.Require(rule, () => Error.ArgumentNull("rule"));
_rule = rule;
}
internal HtmlAttributeRule Clone(HtmlElementRule parent)
{
HtmlAttributeRule current = Clone();
current._element = parent;
return(current);
}
protected void WriteStartElement(HtmlElementRule rule, XmlElement element)
{
if ((rule.Options & HtmlElementOptions.Allowed) == HtmlElementOptions.Allowed)
{
_writer.WriteStartElement(element.LocalName);
WriteAttributes(rule, element.Attributes);
}
}
public HtmlFilterSettings(HtmlFilteringMode processingMode)
{
_document = new HtmlElementRule(null, "html",
HtmlElementOptions.Allowed | HtmlElementOptions.AllowContent |
HtmlElementOptions.UseTypography);
_preserveWhitespace = true;
_mode = processingMode;
}
protected HtmlElementRule GetElementRule(HtmlElementRule parent, string tag)
{
HtmlElementOptions defaultFlags = _settings.DefaultOptions |
((_settings.Mode == HtmlFilteringMode.AllowByDefault)
? HtmlElementOptions.SelfClosing | HtmlElementOptions.Allowed | HtmlElementOptions.AllowContent
: HtmlElementOptions.Denied);
return(GetRuleOrDefault(parent, tag, defaultFlags));
}
public HtmlFormatterFilter(HtmlFilterSettings settings,
HtmlElementRule container, HtmlElementBuilder element,
StringWriter output)
: base(TextReader.Null, output, settings)
{
_contents = output.GetStringBuilder();
_container = container;
_element = element;
}
public HtmlFilterSettings(HtmlFilteringMode processingMode)
{
_document = new HtmlElementRule(null, "html",
HtmlElementOptions.Allowed | HtmlElementOptions.AllowContent |
HtmlElementOptions.UseTypography);
_preserveWhitespace = true;
_mode = processingMode;
}
public virtual HtmlElementRule AddElementRule(HtmlElementRule rule)
{
Precondition.Require(rule, () => Error.ArgumentNull("rule"));
HtmlElementRule current = (rule.Parent == this) ? rule : rule.Clone(this);
_children[current.Name] = current;
return(current);
}
public HtmlFormatterFilter(HtmlFilterSettings settings,
HtmlElementRule container, HtmlElementBuilder element,
StringWriter output)
: base(TextReader.Null, output, settings)
{
_contents = output.GetStringBuilder();
_container = container;
_element = element;
}
public HtmlElementRule Clone()
{
HtmlElementRule current = new HtmlElementRule(_parent, _name, _options);
current._converter = _converter;
_children.CopyTo(current._children);
_attributes.CopyTo(current._attributes);
return(current);
}
protected HtmlAttributeRule GetAttributeRule(HtmlElementRule parent, string attribute)
{
bool isInternal = ((parent.Options & HtmlElementOptions.Generated) == HtmlElementOptions.Generated);
HtmlAttributeOptions flags = (_settings.Mode == HtmlFilteringMode.AllowByDefault || isInternal)
? HtmlAttributeOptions.Allowed : HtmlAttributeOptions.Denied;
return(parent.Attributes[attribute] ?? _settings.Document.Attributes[attribute] ??
new HtmlAttributeRule(_settings.Document, attribute, flags));
}
public HtmlElementResult(XmlElement element,
HtmlElementRule rule)
{
Precondition.Require(element, () =>
Error.ArgumentNull("element"));
Precondition.Require(rule, () =>
Error.ArgumentNull("rule"));
_element = element;
_rule = rule;
}
public HtmlElementResult(XmlElement element,
HtmlElementRule rule)
{
Precondition.Require(element, () =>
Error.ArgumentNull("element"));
Precondition.Require(rule, () =>
Error.ArgumentNull("rule"));
_element = element;
_rule = rule;
}
protected void EnsureRequiredAttributes(HtmlElementRule rule, HashSet <string> usedAttributes)
{
foreach (HtmlAttributeRule attr in rule.Attributes)
{
if ((attr.Options & HtmlAttributeOptions.Required) == HtmlAttributeOptions.Required &&
!usedAttributes.Contains(attr.Name))
{
_writer.WriteAttributeString(attr.Name, attr.DefaultValue);
}
}
}
public HtmlElementRule(HtmlElementRule parent,
string name, HtmlElementOptions flags)
{
Precondition.Defined(name,
() => Error.ArgumentNull("name"));
_name = name;
_options = flags;
_children = new HtmlElementRuleCollection();
_attributes = new HtmlAttributeRuleCollection();
_parent = parent;
}
public HtmlElementRule(HtmlElementRule parent,
string name, HtmlElementOptions flags)
{
Precondition.Defined(name,
() => Error.ArgumentNull("name"));
_name = name;
_options = flags;
_children = new HtmlElementRuleCollection();
_attributes = new HtmlAttributeRuleCollection();
_parent = parent;
}
protected virtual void WriteElement(HtmlElementRule parent, XmlElement element)
{
HtmlElementResult result = ConvertElement(parent, element);
if (result == null)
{
return;
}
WriteStartElement(result.Rule, result.Element);
WriteElementContents(result.Rule, result.Element);
WriteEndElement(result.Rule, result.Element);
}
public HtmlAttributeRule(HtmlElementRule element,
string name, HtmlAttributeOptions flags, string pattern,
string defaultValue)
{
Precondition.Require(element, () => Error.ArgumentNull("element"));
Precondition.Defined(name,
() => Error.ArgumentNull("name"));
_element = element;
_name = name;
_options = flags;
_pattern = pattern;
_defaultValue = defaultValue;
}
protected void WriteElementContents(HtmlElementRule rule, XmlElement element)
{
if ((rule.Options & HtmlElementOptions.Preformatted) == HtmlElementOptions.Preformatted)
{
WriteText(rule, element.InnerXml);
}
else
{
foreach (XmlNode node in element)
{
WriteNode(rule, node);
}
}
}
protected void WriteEndElement(HtmlElementRule rule, XmlElement element)
{
if ((rule.Options & HtmlElementOptions.Allowed) == HtmlElementOptions.Allowed)
{
if ((rule.Options & HtmlElementOptions.SelfClosing) == HtmlElementOptions.SelfClosing)
{
_writer.WriteEndElement();
}
else
{
_writer.WriteFullEndElement();
}
}
}
public HtmlAttributeRule(HtmlElementRule element,
string name, HtmlAttributeOptions flags, string pattern,
string defaultValue)
{
Precondition.Require(element, () => Error.ArgumentNull("element"));
Precondition.Defined(name,
() => Error.ArgumentNull("name"));
_element = element;
_name = name;
_options = flags;
_pattern = pattern;
_defaultValue = defaultValue;
}
protected void WriteAttributes(HtmlElementRule rule, XmlAttributeCollection attributes)
{
HashSet <string> usedAttributes = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
XmlAttribute attr = null;
foreach (XmlAttribute attribute in attributes)
{
if ((attr = WriteAttribute(rule, attribute)) != null)
{
usedAttributes.Add(attr.LocalName);
}
}
EnsureRequiredAttributes(rule, usedAttributes);
}
protected string FormatElement(HtmlElementRule parent,
HtmlElementBuilder element, HtmlElementRenderMode renderMode)
{
using (StringWriter writer = new StringWriter())
{
HtmlFormatterFilter filter = new HtmlFormatterFilter(
_settings, parent, element, writer);
filter.RenderMode = renderMode;
filter.Parameters = Parameters;
filter.Execute();
return(writer.ToString());
}
}
public override void Execute()
{
XmlElement element = CreateContainer();
HtmlElementResult result = ConvertElement(_container, element);
if (result == null)
{
return;
}
HtmlElementRule rule = result.Rule;
WriteStartElement(rule, result.Element);
if (_renderMode == HtmlElementRenderMode.StartTag)
{
_contents.Append('>');
return;
}
WriteElementContents(rule, result.Element);
if (_renderMode == HtmlElementRenderMode.EndTag)
{
_contents.Length = 0;
HtmlElementOptions options = rule.Options;
if ((rule.Options & HtmlElementOptions.SelfClosing) ==
HtmlElementOptions.SelfClosing)
{
rule.Options = (HtmlElementOptions)((byte)rule.Options - 0x04);
}
WriteEndElement(rule, result.Element);
rule.Options = options;
if (_contents.Length > 0 && _contents[0] == '>')
{
_contents.Remove(0, 1);
}
}
else
{
WriteEndElement(rule, result.Element);
}
}
protected HtmlElementRule GetRule(HtmlElementRule parent, string tag)
{
HtmlElementRule tagRule;
if (parent != null)
{
tagRule = parent.Children[tag];
if (tagRule != null)
{
return(tagRule);
}
}
tagRule = GetRule(tag);
if (tagRule != null && (tagRule.Options & HtmlElementOptions.Global)
== HtmlElementOptions.Global)
{
return(tagRule);
}
return(null);
}
public override bool Equals(object obj)
{
if (Object.ReferenceEquals(this, obj))
{
return(true);
}
HtmlElementRule rule = (obj as HtmlElementRule);
if (Object.ReferenceEquals(rule, null))
{
return(false);
}
if (rule.Name.Equals(_name, StringComparison.OrdinalIgnoreCase))
{
return(Object.Equals(_parent, rule._parent));
}
return(false);
}
protected void WriteNode(HtmlElementRule parent, XmlNode node)
{
if (parent == null)
{
return;
}
switch (node.NodeType)
{
case XmlNodeType.Element:
if ((parent.Options & HtmlElementOptions.Container) == HtmlElementOptions.Container)
{
WriteElement(parent, (XmlElement)node);
}
break;
case XmlNodeType.CDATA:
if ((parent.Options & HtmlElementOptions.Text) == HtmlElementOptions.Text)
{
WriteCData(parent, node.Value);
}
break;
case XmlNodeType.Comment:
if ((parent.Options & HtmlElementOptions.Text) == HtmlElementOptions.Text)
{
WriteComment(parent, node.Value);
}
break;
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if ((parent.Options & HtmlElementOptions.Text) == HtmlElementOptions.Text)
{
WriteText(parent, node.Value);
}
break;
}
}
protected virtual void WriteText(HtmlElementRule rule, string text)
{
if ((rule.Options & HtmlElementOptions.UseTypography) ==
HtmlElementOptions.UseTypography)
{
HtmlTypographer typographer = new HtmlTypographer(text, Typographics, _lastState);
typographer.Formatter = (element, mode) => FormatElement(rule, element, mode);
bool lastValue = typographer.Settings.InsertNoBreakTags;
if (String.Equals(rule.Name, "nobr", StringComparison.OrdinalIgnoreCase))
{
typographer.Settings.InsertNoBreakTags = false;
}
_writer.WriteRaw(typographer.Execute());
typographer.Settings.InsertNoBreakTags = lastValue;
_lastState = typographer.State;
}
else
{
_writer.WriteString(text);
}
}
protected HtmlElementResult ConvertElement(HtmlElementRule parent, XmlElement element)
{
Precondition.Require(element, () => Error.ArgumentNull("element"));
HtmlElementRule rule = GetElementRule(parent, element.LocalName);
HtmlElementContext context = new HtmlElementContext(rule.Clone(), Parameters);
if (rule.HasConverter)
{
element = rule.Converter(context, element);
if (element == null)
return null;
if (!MatchName(element, context.Rule))
rule = GetElementRule(parent, element.LocalName);
if ((rule.Options & HtmlElementOptions.Generated) == HtmlElementOptions.Generated)
{
rule = rule.Clone();
rule.Options |= HtmlElementOptions.Allowed;
}
}
return new HtmlElementResult(element, rule);
}
public virtual HtmlElementRule AddElementRule(HtmlElementRule rule)
{
Precondition.Require(rule, () => Error.ArgumentNull("rule"));
HtmlElementRule current = (rule.Parent == this) ? rule : rule.Clone(this);
_children[current.Name] = current;
return current;
}
protected virtual void WriteText(HtmlElementRule rule, string text)
{
if ((rule.Options & HtmlElementOptions.UseTypography) ==
HtmlElementOptions.UseTypography)
{
HtmlTypographer typographer = new HtmlTypographer(text, Typographics, _lastState);
typographer.Formatter = (element, mode) => FormatElement(rule, element, mode);
bool lastValue = typographer.Settings.InsertNoBreakTags;
if (String.Equals(rule.Name, "nobr", StringComparison.OrdinalIgnoreCase))
typographer.Settings.InsertNoBreakTags = false;
_writer.WriteRaw(typographer.Execute());
typographer.Settings.InsertNoBreakTags = lastValue;
_lastState = typographer.State;
}
else
_writer.WriteString(text);
}
protected void WriteStartElement(HtmlElementRule rule, XmlElement element)
{
if ((rule.Options & HtmlElementOptions.Allowed) == HtmlElementOptions.Allowed)
{
_writer.WriteStartElement(element.LocalName);
WriteAttributes(rule, element.Attributes);
}
}
protected HtmlElementRule GetRule(HtmlElementRule parent, string tag)
{
HtmlElementRule tagRule;
if (parent != null)
{
tagRule = parent.Children[tag];
if (tagRule != null)
return tagRule;
}
tagRule = GetRule(tag);
if (tagRule != null && (tagRule.Options & HtmlElementOptions.Global)
== HtmlElementOptions.Global)
return tagRule;
return null;
}
protected virtual void WriteComment(HtmlElementRule rule, string text)
{
_writer.WriteComment(text);
}
public HtmlElementRule Clone()
{
HtmlElementRule current = new HtmlElementRule(_parent, _name, _options);
current._converter = _converter;
_children.CopyTo(current._children);
_attributes.CopyTo(current._attributes);
return current;
}
protected void WriteElementContents(HtmlElementRule rule, XmlElement element)
{
if ((rule.Options & HtmlElementOptions.Preformatted) == HtmlElementOptions.Preformatted)
WriteText(rule, element.InnerXml);
else
foreach (XmlNode node in element)
WriteNode(rule, node);
}
protected HtmlElementRule GetElementRule(HtmlElementRule parent, string tag)
{
HtmlElementOptions defaultFlags = _settings.DefaultOptions |
((_settings.Mode == HtmlFilteringMode.AllowByDefault)
? HtmlElementOptions.SelfClosing | HtmlElementOptions.Allowed | HtmlElementOptions.AllowContent
: HtmlElementOptions.Denied);
return GetRuleOrDefault(parent, tag, defaultFlags);
}
protected bool MatchName(XmlElement element, HtmlElementRule rule)
{
return(String.Equals(element.LocalName, rule.Name, StringComparison.OrdinalIgnoreCase));
}
protected void EnsureRequiredAttributes(HtmlElementRule rule, HashSet<string> usedAttributes)
{
foreach (HtmlAttributeRule attr in rule.Attributes)
{
if ((attr.Options & HtmlAttributeOptions.Required) == HtmlAttributeOptions.Required
&& !usedAttributes.Contains(attr.Name))
_writer.WriteAttributeString(attr.Name, attr.DefaultValue);
}
}
internal HtmlAttributeRule Clone(HtmlElementRule parent)
{
HtmlAttributeRule current = Clone();
current._element = parent;
return current;
}
protected string FormatElement(HtmlElementRule parent,
HtmlElementBuilder element, HtmlElementRenderMode renderMode)
{
using (StringWriter writer = new StringWriter())
{
HtmlFormatterFilter filter = new HtmlFormatterFilter(
_settings, parent, element, writer);
filter.RenderMode = renderMode;
filter.Parameters = Parameters;
filter.Execute();
return writer.ToString();
}
}
protected virtual void WriteElement(HtmlElementRule parent, XmlElement element)
{
HtmlElementResult result = ConvertElement(parent, element);
if (result == null)
return;
WriteStartElement(result.Rule, result.Element);
WriteElementContents(result.Rule, result.Element);
WriteEndElement(result.Rule, result.Element);
}
protected HtmlAttributeResult ConvertAttribute(HtmlElementRule element, XmlAttribute attribute)
{
HtmlAttributeRule attrRule = GetAttributeRule(element, attribute.LocalName);
HtmlAttributeContext context = new HtmlAttributeContext(attrRule.Clone(), Parameters);
if (attrRule.HasConverter)
{
attribute = attrRule.Converter(context, attribute);
if (attribute == null)
return null;
if (!MatchName(attribute, attrRule))
attrRule = GetAttributeRule(element, attribute.LocalName);
if ((attrRule.Options & HtmlAttributeOptions.Generated) == HtmlAttributeOptions.Generated)
{
attrRule = attrRule.Clone();
attrRule.Options |= HtmlAttributeOptions.Allowed;
}
}
return new HtmlAttributeResult(attribute, attrRule);
}
protected void WriteNode(HtmlElementRule parent, XmlNode node)
{
if (parent == null)
return;
switch (node.NodeType)
{
case XmlNodeType.Element:
if ((parent.Options & HtmlElementOptions.Container) == HtmlElementOptions.Container)
WriteElement(parent, (XmlElement)node);
break;
case XmlNodeType.CDATA:
if ((parent.Options & HtmlElementOptions.Text) == HtmlElementOptions.Text)
WriteCData(parent, node.Value);
break;
case XmlNodeType.Comment:
if ((parent.Options & HtmlElementOptions.Text) == HtmlElementOptions.Text)
WriteComment(parent, node.Value);
break;
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if ((parent.Options & HtmlElementOptions.Text) == HtmlElementOptions.Text)
WriteText(parent, node.Value);
break;
}
}
public HtmlElementContext(HtmlElementRule rule)
: this(rule, null)
{
}
protected HtmlElementRule GetRuleOrDefault(HtmlElementRule parent, string tag, HtmlElementOptions options)
{
parent = parent ?? _settings.Document;
return GetRule(parent, tag) ?? new HtmlElementRule(parent, tag, options);
}
protected HtmlElementRule GetRuleOrDefault(HtmlElementRule parent, string tag, HtmlElementOptions options)
{
parent = parent ?? _settings.Document;
return(GetRule(parent, tag) ?? new HtmlElementRule(parent, tag, options));
}
protected HtmlAttributeRule GetAttributeRule(HtmlElementRule parent, string attribute)
{
bool isInternal = ((parent.Options & HtmlElementOptions.Generated) == HtmlElementOptions.Generated);
HtmlAttributeOptions flags = (_settings.Mode == HtmlFilteringMode.AllowByDefault || isInternal)
? HtmlAttributeOptions.Allowed : HtmlAttributeOptions.Denied;
return parent.Attributes[attribute] ?? _settings.Document.Attributes[attribute] ??
new HtmlAttributeRule(_settings.Document, attribute, flags);
}
protected void WriteEndElement(HtmlElementRule rule, XmlElement element)
{
if ((rule.Options & HtmlElementOptions.Allowed) == HtmlElementOptions.Allowed)
{
if ((rule.Options & HtmlElementOptions.SelfClosing) == HtmlElementOptions.SelfClosing)
_writer.WriteEndElement();
else
_writer.WriteFullEndElement();
}
}
public HtmlAttributeRule(HtmlElementRule element,
string name, HtmlAttributeOptions flags, string pattern)
: this(element, name, flags, pattern, null)
{
}
protected virtual void WriteComment(HtmlElementRule rule, string text)
{
_writer.WriteComment(text);
}
protected void WriteAttributes(HtmlElementRule rule, XmlAttributeCollection attributes)
{
HashSet<string> usedAttributes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
XmlAttribute attr = null;
foreach (XmlAttribute attribute in attributes)
if ((attr = WriteAttribute(rule, attribute)) != null)
usedAttributes.Add(attr.LocalName);
EnsureRequiredAttributes(rule, usedAttributes);
}
protected bool MatchName(XmlElement element, HtmlElementRule rule)
{
return String.Equals(element.LocalName, rule.Name, StringComparison.OrdinalIgnoreCase);
}
protected virtual XmlAttribute WriteAttribute(HtmlElementRule element, XmlAttribute attribute)
{
HtmlAttributeResult result = ConvertAttribute(element, attribute);
if (result == null)
return null;
string value = result.Attribute.Value;
if ((result.Rule.Options & HtmlAttributeOptions.Allowed) == HtmlAttributeOptions.Allowed)
{
if ((result.Rule.Options & HtmlAttributeOptions.Default) == HtmlAttributeOptions.Default &&
String.IsNullOrEmpty(value))
value = result.Rule.DefaultValue;
if (result.Rule.ValidateValue(value))
{
_writer.WriteAttributeString(result.Attribute.LocalName, value);
return result.Attribute;
}
}
return null;
}
/// <summary>
/// Adds a top-level rule for the element.
/// </summary>
/// <param name="rule">A new sub-rule to add.</param>
protected virtual HtmlElementRule AddElementRule(HtmlElementRule rule)
{
Precondition.Require(rule, () => Error.ArgumentNull("rule"));
return Document.AddElementRule(rule);
}
