private IMarkdownToken ValidateOne(MarkdownTagInlineToken token, Match m, MarkdownTagValidationRule validator)
{
if (!string.IsNullOrEmpty(validator.CustomValidatorContractName))
{
if (CompositionHost == null)
{
Logger.LogWarning($"Unable to validate tag by contract({validator.CustomValidatorContractName}): CompositionHost is null.");
return(null);
}
var customValidators = GetCustomMarkdownTagValidators(validator);
if (customValidators.Count == 0)
{
Logger.LogWarning($"Cannot find custom markdown tag validator by contract name: {validator.CustomValidatorContractName}.");
return(null);
}
if (customValidators.TrueForAll(av => av.Validate(token.RawMarkdown)))
{
return(null);
}
}
using (new LoggerPhaseScope(StyleCopPhaseName))
{
return(ValidateOneCore(token, m, validator));
}
}
private void ValidateCore(MarkdownTagInlineToken token, Match m, bool isOpeningTag)
{
foreach (var validator in Validators)
{
if (isOpeningTag || !validator.OpeningTagOnly)
{
var hasTagName = validator.TagNames.Any(tagName => string.Equals(tagName, m.Groups[1].Value, System.StringComparison.OrdinalIgnoreCase));
if (hasTagName ^ (validator.Relation == TagRelation.NotIn))
{
ValidateOne(token, m, validator);
}
}
}
return;
}
private void ValidateOneCore(MarkdownTagInlineToken token, Match m, MarkdownTagValidationRule validator)
{
switch (validator.Behavior)
{
case TagValidationBehavior.Warning:
Logger.LogWarning(string.Format(validator.MessageFormatter, m.Groups[1].Value, token.SourceInfo.Markdown));
return;
case TagValidationBehavior.Error:
Logger.LogError(string.Format(validator.MessageFormatter, m.Groups[1].Value, token.SourceInfo.Markdown));
return;
case TagValidationBehavior.None:
default:
return;
}
}
public void Validate(MarkdownTagInlineToken token)
{
var m = OpeningTag.Match(token.SourceInfo.Markdown);
bool isOpeningTag = true;
if (m.Length == 0)
{
m = ClosingTag.Match(token.SourceInfo.Markdown);
if (m.Length == 0)
{
return;
}
isOpeningTag = false;
}
ValidateCore(token, m, isOpeningTag);
}
private IMarkdownToken ValidateCore(MarkdownTagInlineToken token, Match m, bool isOpeningTag)
{
foreach (var validator in Validators)
{
if (isOpeningTag || !validator.OpeningTagOnly)
{
foreach (var tagName in validator.TagNames)
{
if (string.Equals(tagName, m.Groups[1].Value, System.StringComparison.OrdinalIgnoreCase))
{
return(ValidateOne(token, m, validator));
}
}
}
}
return(null);
}
public IMarkdownToken Validate(MarkdownEngine engine, MarkdownTagInlineToken token)
{
var m = OpeningTag.Match(token.Content);
bool isOpeningTag = true;
if (m.Length == 0)
{
m = ClosingTag.Match(token.Content);
if (m.Length == 0)
{
return(null);
}
isOpeningTag = false;
}
return(ValidateCore(token, m, isOpeningTag));
}
private IMarkdownToken ValidateOneCore(MarkdownTagInlineToken token, Match m, MarkdownTagValidationRule validator)
{
switch (validator.Behavior)
{
case TagRewriteBehavior.Warning:
Logger.LogWarning(string.Format(validator.MessageFormatter, m.Groups[1].Value, token.Content));
return(null);
case TagRewriteBehavior.Error:
Logger.LogError(string.Format(validator.MessageFormatter, m.Groups[1].Value, token.Content));
return(null);
case TagRewriteBehavior.ErrorAndRemove:
Logger.LogError(string.Format(validator.MessageFormatter, m.Groups[1].Value, token.Content));
return(new MarkdownIgnoreToken(token.Rule));
case TagRewriteBehavior.None:
default:
return(null);
}
}
public virtual StringBuffer Render(IMarkdownRenderer renderer, MarkdownTagInlineToken token, MarkdownInlineContext context)
{
return(Insert(token, ExposeTokenName(token)));
}
public StringBuffer Render(IMarkdownRenderer render, MarkdownTagInlineToken token, IMarkdownContext context)
{
return(token.SourceInfo.Markdown);
}
public virtual StringBuffer Render(IMarkdownRenderer renderer, MarkdownTagInlineToken token, MarkdownInlineContext context)
{
return Insert(token, ExposeTokenName(token));
}
