public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
await base.ProcessAsync(context, output);
string content = null;
if (Markdown != null)
{
content = Markdown.Model?.ToString();
}
if (content == null)
{
content = (await output.GetChildContentAsync(NullHtmlEncoder.Default))
.GetContent(NullHtmlEncoder.Default);
}
if (string.IsNullOrEmpty(content))
{
return;
}
content = content.Trim('\n', '\r');
//string markdown = NormalizeWhiteSpaceText(content);
string markdown = (content);
var parser = MarkdownParserFactory.GetParser();
var html = parser.Parse(markdown);
output.TagName = null; // Remove the <markdown> element
output.Content.SetHtmlContent(html);
}
public void ShouldReturnListOfParserNamesContainingTheDefaultParserNameWhenNoAddinsLoaded()
{
List <string> names = MarkdownParserFactory.GetParserNames();
Assert.AreEqual(1, names.Count);
Assert.AreEqual(MarkdownParserFactory.DefaultMarkdownParserName, names.First());
}
public void ShouldFetchAddinParserByAddinId()
{
_loadAddin(new CustomParserAddin());
var parser = MarkdownParserFactory.GetParser(parserAddinId: "CustomParserAddin");
Assert.IsInstanceOfType(parser, typeof(CustomParser));
}
public void ShouldReturnTheSpecifiedParser()
{
_loadAddin(new CustomParserAddin());
var parser = MarkdownParserFactory.GetParser(parserAddinId: "CustomParser");
Assert.IsInstanceOfType(parser, typeof(CustomParser));
}
public void ShouldReturnTheSpecifiedParserWhenForceLoadArgIsTrue()
{
_loadAddin(new CustomParserAddin());
MarkdownParserFactory.GetParser();
var parser = MarkdownParserFactory.GetParser(forceLoad: true, addinId: "CustomParser");
Assert.IsInstanceOfType(parser, typeof(CustomParser));
}
public void TestStrikeOut()
{
string markdown = "This is **bold** and this is ~~strike out text~~ and this is ~~too~~. This ~~ is text \r\n that continues~~.";
var parser = MarkdownParserFactory.GetParser(true);
string html = parser.Parse(markdown);
Console.WriteLine(html);
}
public void ShouldReturnTheCachedParserWhenForceLoadArgIsFalse()
{
_loadAddin(new CustomParserAddin());
MarkdownParserFactory.GetParser();
var parser = MarkdownParserFactory.GetParser(forceLoad: false, parserAddinId: "CustomParser");
Assert.IsInstanceOfType(parser, typeof(MarkdownParserMarkdig));
}
/// <summary>
/// Arranges the permuted markdown and acts to parse it into HTML.
/// </summary>
/// <param name="lead">The leading characters.</param>
/// <param name="trail">The closing characters.</param>
/// <returns>The generated HTML for the permutation</returns>
private static string CreateMarkdownPermutation(string lead, string trail)
{
var markdown = PermutationMarkdown.Replace("{lead}", lead)
.Replace("{trail}", trail);
var parser = MarkdownParserFactory.GetParser(usePragmaLines: false, forceLoad: true);
string html = parser.Parse(markdown);
return(html);
}
public void HtmlLineBreakTest()
{
string markdown = "This is a test<br>Line 2";
var parser = MarkdownParserFactory.GetParser();
string html = parser.Parse(markdown);
Console.WriteLine(markdown);
Console.WriteLine(html);
}
/// <summary>
/// Renders raw markdown from string to HTML
/// </summary>
/// <param name="markdown">Markdown to Render</param>
/// <param name="usePragmaLines">Generates line numbers as ids into headers and paragraphs. Useful for previewers to match line numbers to rendered output</param>
/// <param name="forceReload">Forces the parser to be reloaded completely rather than using a cached instance</param>
/// <param name="sanitizeHtml">Strips out scriptable tags and attributes for prevent XSS attacks. Minimal implementation.</param>
/// <returns></returns>
public static string Parse(string markdown, bool usePragmaLines = false, bool forceReload = false, bool sanitizeHtml = true)
{
if (string.IsNullOrEmpty(markdown))
{
return("");
}
var parser = MarkdownParserFactory.GetParser(usePragmaLines, forceReload);
return(parser.Parse(markdown, sanitizeHtml));
}
public void ShouldReturnListOfParserNamesLoaded()
{
_loadAddin(new CustomParserAddin());
var names = MarkdownParserFactory.GetParserNames();
Assert.AreEqual(2, names.Count);
CollectionAssert.AreEqual(new List <string> {
MarkdownParserFactory.DefaultMarkdownParserName, "CustomParser"
}, names);
}
public void FontAwesomeTest()
{
string markdown = @"
this @icon-gear<span>Text</span>
I can see that this is working @icon-warning";
var parser = MarkdownParserFactory.GetParser();
string html = parser.Parse(markdown);
Console.WriteLine(html);
Assert.IsTrue(html.Contains("fa-warning") && html.Contains("fa-gear"));
}
/// <summary>
/// Overrides the HTML rendering of content
/// </summary>
/// <param name="writer"></param>
protected override void Render(HtmlTextWriter writer)
{
string markdown = null;
if (!string.IsNullOrEmpty(Filename))
{
var file = Context.Server.MapPath(Filename);
try
{
markdown = File.ReadAllText(file);
}
catch
{
return;
}
}
else
{
if (string.IsNullOrEmpty(Text))
{
return;
}
if (NormalizeWhiteSpace)
{
markdown = NormalizeWhiteSpaceText(Text);
}
else
{
markdown = Text;
}
}
var parser = MarkdownParserFactory.GetParser(false, false);
var html = parser.Parse(markdown, SanitizeHtml);
writer.Write(html);
}
public void PragmaLinesTest()
{
string markdown = @"# Item 1
This is some Markdown text that is **bold**.
http://west-wind.com
## header 2
This is ~~strike out text~~ and this is ~~too~~. This ~~is text \r\n that continues~~.
* Item 1
askdjlaks jdalksdjalskdj
asdkljaslkdjalskdjasd
<b>This is more text</b>";
var parser = MarkdownParserFactory.GetParser(usePragmaLines: true);
string html = parser.Parse(markdown);
Console.WriteLine(html);
Assert.IsTrue(html.Contains("pragma-line-13"));
}
/// <summary>
/// Takes the input collection and parses it into an HTML string. First row is considered to be the
/// header of the table.
/// </summary>
/// <param name="tableData"></param>
/// <returns></returns>
public string ToTableHtml(TableData tableData = null)
{
if (tableData == null)
{
tableData = TableData;
}
if (tableData == null || tableData.Rows.Count < 1 && tableData.Headers.Count < 1)
{
return(string.Empty);
}
var mdParser = MarkdownParserFactory.GetParser(usePragmaLines: false, forceLoad: true);
var columnInfo = GetColumnInfo(tableData);
StringBuilder sb = new StringBuilder();
sb.Clear();
sb.AppendLine("\n<table>");
sb.AppendLine("<thead>");
sb.AppendLine("\t<tr>");
for (int i = 0; i < columnInfo.Count; i++)
{
var colInfo = columnInfo[i];
var align = string.Empty;
if (columnInfo[i].Justification == ColumnJustifications.Right)
{
align = " style=\"text-align:right\"";
}
else if (columnInfo[i].Justification == ColumnJustifications.Center)
{
align = " style=\"text-align:center\"";
}
sb.AppendLine($"\t\t<th{align}>{WebUtility.HtmlEncode(colInfo.Title.Trim(' ',':','\n','\r'))}</th>");
}
sb.AppendLine("\t</tr>");
sb.AppendLine("</thead>");
sb.AppendLine("<tbody>");
foreach (var row in tableData.Rows)
{
sb.AppendLine("\t<tr>");
for (int i = 0; i < columnInfo.Count; i++)
{
var col = row[i];
if (string.IsNullOrEmpty(col))
{
col = string.Empty;
}
else
{
col = col.Replace("\n", "<br>")
.Replace("\r", "");
}
var align = string.Empty;
if (columnInfo[i].Justification == ColumnJustifications.Right)
{
align = " style=\"text-align: right\"";
}
else if (columnInfo[i].Justification == ColumnJustifications.Center)
{
align = " style=\"text-align: center\"";
}
var text = mdParser.Parse(col.Trim())
.Replace("<p>", "")
.Replace("</p>", "")
.Trim();
sb.AppendLine($"\t\t<td{align}>{text}</td>");
}
sb.AppendLine("\t</tr>");
}
sb.AppendLine("</tbody>");
sb.AppendLine($"</table>{mmApp.NewLine}");
return(sb.ToString());
}
public void ShouldReturnTheDefaultMarkdownParserWhenUnkownParserNameGiven()
{
var parser = MarkdownParserFactory.GetParser(parserAddinId: "BogusParser");
Assert.IsInstanceOfType(parser, typeof(MarkdownParserMarkdig));
}
public void ShouldReturnTheDefaultParserWhenNoArgsGiven()
{
var parser = MarkdownParserFactory.GetParser();
Assert.IsInstanceOfType(parser, typeof(MarkdownParserMarkdig));
}
