public IMarkdownTokenRewriter Create()
{
var list = new List <IMarkdownTokenValidator>();
foreach (var contract in ValidatorContracts)
{
foreach (IMarkdownTokenValidatorProvider vp in CompositionHost.GetExports(typeof(IMarkdownTokenValidatorProvider), contract))
{
list.AddRange(vp.GetValidators());
}
}
var context = new MarkdownRewriterContext(CompositionHost, TagValidators);
list.Add(MarkdownTokenValidatorFactory.FromLambda <MarkdownTagInlineToken>(context.Validate));
return(MarkdownTokenRewriterFactory.FromLambda(
(IMarkdownRewriteEngine engine, IMarkdownToken token) =>
{
using (new LoggerPhaseScope(MarkdownValidatePhaseName))
{
foreach (var item in list)
{
item.Validate(token);
}
}
return null;
}));
}
public void TestGfmWithValidator()
{
const string source = "#Hello World";
const string expected = "<h1 id=\"hello-world\">Hello World</h1>\n";
const string expectedMessage = "a space is expected after '#'";
string message = null;
var builder = new GfmEngineBuilder(new Options
{
LegacyMode = true,
});
builder.Rewriter =
MarkdownTokenRewriterFactory.FromValidators(
MarkdownTokenValidatorFactory.FromLambda(
(MarkdownHeadingBlockToken token) =>
{
if (!token.SourceInfo.Markdown.StartsWith("# "))
{
message = expectedMessage;
}
}));
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
Assert.Equal(expectedMessage, message);
}
public IMarkdownTokenRewriter CreateRewriter()
{
var context = new MarkdownRewriterContext(Container, GetEnabledTagRules().ToImmutableList());
return(new MarkdownTokenRewriteWithScope(
MarkdownTokenRewriterFactory.FromValidators(
MarkdownValidatePhaseName,
GetEnabledRules().Concat(
new[]
{
MarkdownTokenValidatorFactory.FromLambda <IMarkdownToken>(context.Validate)
})),
MarkdownValidatePhaseName));
}
public void TestGfmWithValidatorWithQuery()
{
const string source = @"abc (not match)
- abc (match)
- a*b*c (match)
- xyz
- x
> a**b**c (not match)";
const string expected = @"<p>abc (not match)</p>
<ul>
<li>abc (match)</li>
<li>a<em>b</em>c (match)</li>
<li>xyz</li>
<li>x</li>
</ul>
<blockquote>
<p>a<strong>b</strong>c (not match)</p>
</blockquote>
";
int matchCount = 0;
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownTokenRewriterFactory.FromValidators(
MarkdownTokenValidatorFactory.FromLambda(
(MarkdownListItemBlockToken token) =>
{
var text = string.Concat(from t in token.Descendants <MarkdownTextToken>() select t.Content);
if (text.Contains("abc"))
{
matchCount++;
}
}));
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
Assert.Equal(2, matchCount);
}
public void TestGfmWithValidatorWithContext()
{
const string source = @"# Title-1
# Title-2";
const string expected = @"<h1 id=""title-1"">Title-1</h1>
<h1 id=""title-2"">Title-2</h1>
";
const string expectedMessage = "expected one title in one document.";
string message = null;
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownTokenRewriterFactory.FromValidators(
MarkdownTokenValidatorFactory.FromLambda(
(MarkdownHeadingBlockToken token) =>
{
var re = MarkdownTokenValidatorContext.CurrentRewriteEngine;
if (token.Depth == 1)
{
re.SetVariable("count", (int)re.GetVariable("count") + 1);
}
},
re =>
{
re.SetVariable("count", 0);
re.SetPostProcess("h1 count", re1 =>
{
if ((int)re.GetVariable("count") != 1)
{
message = expectedMessage;
}
});
}));
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
Assert.Equal(expectedMessage, message);
}
public void TestGfmWithValidatorWithParents()
{
const string source = @"# abc
> *abc*
- abc
abc
";
const string expected = @"<h1 id=""abc"">abc</h1>
<blockquote>
<p><em>abc</em></p>
</blockquote>
<ul>
<li>abc</li>
</ul>
<p>abc</p>
";
int headingTextCount = 0;
int blockquoteTextCount = 0;
int listTextCount = 0;
int paraTextCount = 0;
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownTokenRewriterFactory.FromValidators(
MarkdownTokenValidatorFactory.FromLambda(
(MarkdownTextToken token) =>
{
if (token.Content == "abc")
{
var re = MarkdownTokenValidatorContext.CurrentRewriteEngine;
foreach (var parent in re.GetParents())
{
if (parent is MarkdownHeadingBlockToken)
{
headingTextCount++;
}
else if (parent is MarkdownBlockquoteBlockToken)
{
blockquoteTextCount++;
}
else if (parent is MarkdownListItemBlockToken)
{
listTextCount++;
}
else if (parent is MarkdownParagraphBlockToken)
{
paraTextCount++;
}
}
}
}));
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
Assert.Equal(1, headingTextCount);
Assert.Equal(1, blockquoteTextCount);
Assert.Equal(1, listTextCount);
Assert.Equal(2, paraTextCount);
}
public ImmutableArray <IMarkdownTokenValidator> GetValidators()
{
return(ImmutableArray.Create(
MarkdownTokenValidatorFactory.FromLambda <MarkdownHtmlBlockToken>(
token => Logger.LogWarning(WarningMessage))));
}
