Merge remote-tracking branch 'origin/normalize'

This commit is contained in:
Alexandre Mutel
2017-10-25 17:11:15 +02:00
23 changed files with 1038 additions and 1 deletions

View File

@@ -61,6 +61,7 @@
<Compile Include="TestHtmlHelper.cs" />
<Compile Include="TestLineReader.cs" />
<Compile Include="TestLinkHelper.cs" />
<Compile Include="TestNormalize.cs" />
<Compile Include="TestOrderedList.cs" />
<Compile Include="TestPragmaLines.cs" />
<Compile Include="TestSourcePosition.cs" />

View File

@@ -0,0 +1,339 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using System;
using NUnit.Framework;
using Markdig.Syntax;
using Markdig.Syntax.Inlines;
using System.IO;
using Markdig.Renderers.Normalize;
using Markdig.Helpers;
namespace Markdig.Tests
{
[TestFixture]
public class TestNormalize
{
[Test]
public void TestNormalizeSyntaxCodeBlock()
{
AssertSyntax("````csharp\npublic void HelloWorld()\n{\n}\n````", new FencedCodeBlock(null)
{
FencedChar = '`',
FencedCharCount = 4,
Info = "csharp",
Lines = new StringLineGroup(4)
{
new StringSlice("public void HelloWorld()"),
new StringSlice("{"),
new StringSlice("}"),
}
});
AssertSyntax(" public void HelloWorld()\n {\n }", new CodeBlock(null)
{
Lines = new StringLineGroup(4)
{
new StringSlice("public void HelloWorld()"),
new StringSlice("{"),
new StringSlice("}"),
}
});
}
[Test]
public void TestNormalizeSyntaxHeadline()
{
AssertSyntax("## Headline", new HeadingBlock(null)
{
HeaderChar = '#',
Level = 2,
Inline = new ContainerInline().AppendChild(new LiteralInline("Headline")),
});
}
[Test]
public void TestNormalizeSyntaxParagraph()
{
AssertSyntax("This is a normal paragraph", new ParagraphBlock()
{
Inline = new ContainerInline()
.AppendChild(new LiteralInline("This is a normal paragraph")),
});
AssertSyntax("This is a\nnormal\nparagraph", new ParagraphBlock()
{
Inline = new ContainerInline()
.AppendChild(new LiteralInline("This is a"))
.AppendChild(new LineBreakInline())
.AppendChild(new LiteralInline("normal"))
.AppendChild(new LineBreakInline())
.AppendChild(new LiteralInline("paragraph")),
});
}
[Test]
public void TestNormalizeRoundtripCodeBlock()
{
AssertNormalizeNoTrim(" public void HelloWorld();\n {\n }");
AssertNormalizeNoTrim(" public void HelloWorld();\n {\n }\n\ntext after two newlines");
AssertNormalizeNoTrim("````\npublic void HelloWorld();\n{\n}\n````\n\ntext after two newlines");
AssertNormalizeNoTrim("````csharp\npublic void HelloWorld();\n{\n}\n````");
AssertNormalizeNoTrim("````csharp hideNewKeyword=true\npublic void HelloWorld();\n{\n}\n````");
}
[Test]
public void TestNormalizeRoundtripHeading()
{
AssertNormalizeNoTrim("# Heading");
AssertNormalizeNoTrim("## Heading");
AssertNormalizeNoTrim("### Heading");
AssertNormalizeNoTrim("#### Heading");
AssertNormalizeNoTrim("##### Heading");
AssertNormalizeNoTrim("###### Heading");
AssertNormalizeNoTrim("###### Heading\n\ntext after two newlines");
AssertNormalizeNoTrim("Heading\n=======\n\ntext after two newlines", "# Heading\n\ntext after two newlines");
}
[Test]
public void TestNormalizeRoundtripHtml()
{
/*AssertNormalizeNoTrim(@"<div id=""foo"" class=""bar
baz"">
</ div >");*/ // TODO: Bug: Throws Exception during emit
}
[Test]
public void TestNormalizeRoundtripParagraph()
{
AssertNormalizeNoTrim("This is a plain paragraph");
AssertNormalizeNoTrim(@"This
is
a
plain
paragraph");
}
[Test]
public void TestNormalizeRoundtripParagraphMulti()
{
AssertNormalizeNoTrim(@"line1
line2
line3");
}
[Test]
public void TestNormalizeRoundtripListUnordered()
{
AssertNormalizeNoTrim(@"- a
- b
- c");
}
[Test]
public void TestNormalizeRoundtripListOrdered()
{
AssertNormalizeNoTrim(@"1. a
2. b
3. c");
}
[Test]
public void TestNormalizeRoundtripListOrderedAndIntended()
{
AssertNormalizeNoTrim(@"1. a
2. b
- foo
- bar
a) 1234
b) 1324
3. c
4. c
5. c
6. c
7. c
8. c
9. c
10. c
- Foo
- Bar
11. c
12. c");
}
[Test]
public void TestNormalizeRoundtripHeaderAndParagraph()
{
AssertNormalizeNoTrim(@"# heading
paragraph
paragraph2 without newlines");
}
[Test]
public void TestNormalizeRoundtripQuoteBlock()
{
AssertNormalizeNoTrim(@"> test1
>
> test2");
AssertNormalizeNoTrim(@"> test1
> -foobar
asdf
> test2
> -foobar sen.");
}
[Test]
public void TestNormalizeRoundtripThematicBreak()
{
AssertNormalizeNoTrim("***\n");
AssertNormalizeNoTrim("* * *\n", "***\n");
}
[Test]
public void TestNormalizeRoundtripAutolinkInline()
{
AssertNormalizeNoTrim("This has a <auto.link.com>");
}
[Test]
public void TestNormalizeRoundtripCodeInline()
{
AssertNormalizeNoTrim("This has a `HelloWorld()` in it");
AssertNormalizeNoTrim(@"This has a ``Hello`World()`` in it");
}
[Test]
public void TestNormalizeRoundtripEmphasisInline()
{
AssertNormalizeNoTrim("This is a plain **paragraph**");
AssertNormalizeNoTrim("This is a plain *paragraph*");
AssertNormalizeNoTrim("This is a plain _paragraph_");
AssertNormalizeNoTrim("This is a plain __paragraph__");
AssertNormalizeNoTrim("This is a pl*ai*n **paragraph**");
}
[Test]
public void TestNormalizeRoundtripLineBreakInline()
{
AssertNormalizeNoTrim("normal\nline break");
AssertNormalizeNoTrim("hard \nline break");
}
[Test]
public void TestNormalizeRoundtripLinkInline()
{
AssertNormalizeNoTrim("This is a [link](http://company.com)");
AssertNormalizeNoTrim("This is an ![image](http://company.com)");
AssertNormalizeNoTrim(@"This is a [link](http://company.com ""Crazy Company"")");
AssertNormalizeNoTrim(@"This is a [link](http://company.com ""Crazy \"" Company"")");
}
[Test]
public void TestNormalizeRoundtripHtmlEntityInline()
{
AssertNormalizeNoTrim("This is a &auml; blank");
}
[Test]
public void TestNormalizeRoundtripHtmlInline()
{
AssertNormalizeNoTrim("foo <hr/> bar");
AssertNormalizeNoTrim(@"foo <hr foo=""bar""/> bar");
}
[Test]
public void TestNormalizeRoundtripSpaceBetweenNodes()
{
AssertNormalizeNoTrim("# Hello World\nFoobar is a better bar.",
"# Hello World\n\nFoobar is a better bar.");
}
[Test]
public void TestNormalizeRoundtripSpaceBetweenNodesEvenForHeadlines()
{
AssertNormalizeNoTrim("# Hello World\n## Chapter 1\nFoobar is a better bar.",
"# Hello World\n\n## Chapter 1\n\nFoobar is a better bar.");
}
[Test]
public void TestNormalizeRoundtripSpaceRemoveAtStartAndEnd()
{
AssertNormalizeNoTrim("\n\n# Hello World\n## Chapter 1\nFoobar is a better bar.\n\n",
"# Hello World\n\n## Chapter 1\n\nFoobar is a better bar.");
}
[Test]
public void TestNormalizeRoundtripSpaceShortenBetweenNodes()
{
AssertNormalizeNoTrim("# Hello World\n\n\n\nFoobar is a better bar.",
"# Hello World\n\nFoobar is a better bar.");
}
private static void AssertSyntax(string expected, MarkdownObject syntax)
{
var writer = new StringWriter();
var normalizer = new NormalizeRenderer(writer);
var document = new MarkdownDocument();
if (syntax is Block)
{
document.Add(syntax as Block);
}
else
{
throw new InvalidOperationException();
}
normalizer.Render(document);
var actual = writer.ToString();
Assert.AreEqual(expected, actual);
}
public void AssertNormalizeNoTrim(string input, string expected = null)
=> AssertNormalize(input, expected, false);
public void AssertNormalize(string input, string expected = null, bool trim = true)
{
expected = expected ?? input;
input = NormText(input, trim);
expected = NormText(expected, trim);
var result = Markdown.Normalize(input);
result = NormText(result, trim);
Console.WriteLine("```````````````````Source");
Console.WriteLine(TestParser.DisplaySpaceAndTabs(input));
Console.WriteLine("```````````````````Result");
Console.WriteLine(TestParser.DisplaySpaceAndTabs(result));
Console.WriteLine("```````````````````Expected");
Console.WriteLine(TestParser.DisplaySpaceAndTabs(expected));
Console.WriteLine("```````````````````");
Console.WriteLine();
TextAssert.AreEqual(expected, result);
}
private static string NormText(string text, bool trim)
{
if (trim)
{
text = text.Trim();
}
return text.Replace("\r\n", "\n").Replace('\r', '\n');
}
}
}

View File

@@ -7,6 +7,7 @@ using System.Reflection;
using Markdig.Extensions.SelfPipeline;
using Markdig.Parsers;
using Markdig.Renderers;
using Markdig.Renderers.Normalize;
using Markdig.Syntax;
namespace Markdig
@@ -22,6 +23,42 @@ namespace Markdig
public static readonly string Version = ((AssemblyFileVersionAttribute) typeof(Markdown).Assembly.GetCustomAttributes(typeof(AssemblyFileVersionAttribute), false)[0]).Version;
#endif
/// <summary>
/// Normalizes the specified markdown to a normalized markdown text.
/// </summary>
/// <param name="markdown">The markdown.</param>
/// <param name="pipeline">The pipeline.</param>
/// <returns>A normalized markdown text.</returns>
public static string Normalize(string markdown, MarkdownPipeline pipeline = null)
{
var writer = new StringWriter();
Normalize(markdown, writer, pipeline);
return writer.ToString();
}
/// <summary>
/// Normalizes the specified markdown to a normalized markdown text.
/// </summary>
/// <param name="markdown">The markdown.</param>
/// <param name="writer">The destination <see cref="TextWriter"/> that will receive the result of the conversion.</param>
/// <param name="pipeline">The pipeline.</param>
/// <returns>A normalized markdown text.</returns>
public static MarkdownDocument Normalize(string markdown, TextWriter writer, MarkdownPipeline pipeline = null)
{
pipeline = pipeline ?? new MarkdownPipelineBuilder().Build();
pipeline = CheckForSelfPipeline(pipeline, markdown);
// We override the renderer with our own writer
var renderer = new NormalizeRenderer(writer);
pipeline.Setup(renderer);
var document = Parse(markdown, pipeline);
renderer.Render(document);
writer.Flush();
return document;
}
/// <summary>
/// Converts a Markdown string to HTML.
/// </summary>

View File

@@ -88,7 +88,9 @@ namespace Markdig.Parsers
processor.NewBlocks.Push(new ThematicBreakBlock(this)
{
Column = processor.Column,
Span = new SourceSpan(startPosition, line.End)
Span = new SourceSpan(startPosition, line.End),
ThematicChar = breakChar,
ThematicCharCount = breakCharCount
});
return BlockState.BreakDiscard;
}

View File

@@ -0,0 +1,57 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Renderers.Html;
using Markdig.Syntax;
namespace Markdig.Renderers.Normalize
{
/// <summary>
/// An Normalize renderer for a <see cref="CodeBlock"/> and <see cref="FencedCodeBlock"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.CodeBlock}" />
public class CodeBlockRenderer : NormalizeObjectRenderer<CodeBlock>
{
public bool OutputAttributesOnPre { get; set; }
protected override void Write(NormalizeRenderer renderer, CodeBlock obj)
{
var fencedCodeBlock = obj as FencedCodeBlock;
if (fencedCodeBlock != null)
{
var opening = new string(fencedCodeBlock.FencedChar, fencedCodeBlock.FencedCharCount);
renderer.Write(opening);
if (fencedCodeBlock.Info != null)
{
renderer.Write(fencedCodeBlock.Info);
}
if (string.IsNullOrEmpty(fencedCodeBlock.Arguments) == false)
{
renderer.Write(" ").Write(fencedCodeBlock.Arguments);
}
/* TODO do we need this causes a empty space and would render html attributes to markdown.
var attributes = obj.TryGetAttributes();
if (attributes != null)
{
renderer.Write(" ");
renderer.Write(attributes);
}
*/
renderer.WriteLine();
renderer.WriteLeafRawLines(obj, true);
renderer.Write(opening);
renderer.FinishBlock();
}
else
{
renderer.WriteLeafRawLines(obj, false, true);
renderer.FinishBlock();
}
}
}
}

View File

@@ -0,0 +1,36 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using System.Globalization;
using Markdig.Syntax;
namespace Markdig.Renderers.Normalize
{
/// <summary>
/// An Normalize renderer for a <see cref="HeadingBlock"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.HeadingBlock}" />
public class HeadingRenderer : NormalizeObjectRenderer<HeadingBlock>
{
private static readonly string[] HeadingTexts = {
"#",
"##",
"###",
"####",
"#####",
"######",
};
protected override void Write(NormalizeRenderer renderer, HeadingBlock obj)
{
var headingText = obj.Level > 0 && obj.Level <= 6
? HeadingTexts[obj.Level - 1]
: new string('#', obj.Level);
renderer.Write(headingText).Write(' ');
renderer.WriteLeafInline(obj);
renderer.FinishBlock();
}
}
}

View File

@@ -0,0 +1,19 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax.Inlines;
namespace Markdig.Renderers.Normalize.Inlines
{
/// <summary>
/// A Normalize renderer for an <see cref="AutolinkInline"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.Inlines.AutolinkInline}" />
public class AutolinkInlineRenderer : NormalizeObjectRenderer<AutolinkInline>
{
protected override void Write(NormalizeRenderer renderer, AutolinkInline obj)
{
renderer.Write('<').Write(obj.Url).Write('>');
}
}
}

View File

@@ -0,0 +1,23 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax.Inlines;
namespace Markdig.Renderers.Normalize.Inlines
{
/// <summary>
/// A Normalize renderer for a <see cref="CodeInline"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.Inlines.CodeInline}" />
public class CodeInlineRenderer : NormalizeObjectRenderer<CodeInline>
{
protected override void Write(NormalizeRenderer renderer, CodeInline obj)
{
var delimiter = obj.Content.Contains(obj.Delimiter + "") ? new string(obj.Delimiter, 2) : obj.Delimiter + "";
renderer.Write(delimiter);
renderer.Write(obj.Content);
renderer.Write(delimiter);
}
}
}

View File

@@ -0,0 +1,20 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax.Inlines;
namespace Markdig.Renderers.Normalize.Inlines
{
/// <summary>
/// A Normalize renderer for a <see cref="DelimiterInline"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.Inlines.DelimiterInline}" />
public class DelimiterInlineRenderer : NormalizeObjectRenderer<DelimiterInline>
{
protected override void Write(NormalizeRenderer renderer, DelimiterInline obj)
{
renderer.Write(obj.ToLiteral());
renderer.WriteChildren(obj);
}
}
}

View File

@@ -0,0 +1,22 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax.Inlines;
namespace Markdig.Renderers.Normalize.Inlines
{
/// <summary>
/// A Normalize renderer for an <see cref="EmphasisInline"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.Inlines.EmphasisInline}" />
public class EmphasisInlineRenderer : NormalizeObjectRenderer<EmphasisInline>
{
protected override void Write(NormalizeRenderer renderer, EmphasisInline obj)
{
var emphasisText = new string(obj.DelimiterChar, obj.IsDouble ? 2 : 1);
renderer.Write(emphasisText);
renderer.WriteChildren(obj);
renderer.Write(emphasisText);
}
}
}

View File

@@ -0,0 +1,29 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax.Inlines;
namespace Markdig.Renderers.Normalize.Inlines
{
/// <summary>
/// A Normalize renderer for a <see cref="LineBreakInline"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.Inlines.LineBreakInline}" />
public class LineBreakInlineRenderer : NormalizeObjectRenderer<LineBreakInline>
{
/// <summary>
/// Gets or sets a value indicating whether to render this softline break as a Normalize hardline break tag (&lt;br /&gt;)
/// </summary>
public bool RenderAsHardlineBreak { get; set; }
protected override void Write(NormalizeRenderer renderer, LineBreakInline obj)
{
if (obj.IsHard)
{
renderer.Write(" ");
}
renderer.WriteLine();
}
}
}

View File

@@ -0,0 +1,38 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax.Inlines;
namespace Markdig.Renderers.Normalize.Inlines
{
/// <summary>
/// A Normalize renderer for a <see cref="LinkInline"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.Inlines.LinkInline}" />
public class LinkInlineRenderer : NormalizeObjectRenderer<LinkInline>
{
protected override void Write(NormalizeRenderer renderer, LinkInline link)
{
if (link.IsImage)
{
renderer.Write('!');
}
renderer.Write('[');
renderer.WriteChildren(link);
renderer.Write(']');
if (!string.IsNullOrEmpty(link.Url))
{
renderer.Write('(').Write(link.Url);
if (!string.IsNullOrEmpty(link.Title))
{
renderer.Write(" \"");
renderer.Write(link.Title.Replace(@"""", @"\"""));
renderer.Write("\"");
}
renderer.Write(')');
}
}
}
}

View File

@@ -0,0 +1,19 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax.Inlines;
namespace Markdig.Renderers.Normalize.Inlines
{
/// <summary>
/// A Normalize renderer for a <see cref="LiteralInline"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.Inlines.LiteralInline}" />
public class LiteralInlineRenderer : NormalizeObjectRenderer<LiteralInline>
{
protected override void Write(NormalizeRenderer renderer, LiteralInline obj)
{
renderer.Write(ref obj.Content);
}
}
}

View File

@@ -0,0 +1,18 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax.Inlines;
namespace Markdig.Renderers.Normalize.Inlines
{
/// <summary>
/// A Normalize renderer for a <see cref="HtmlEntityInline"/>.
/// </summary>
public class NormalizeHtmlEntityInlineRenderer : NormalizeObjectRenderer<HtmlEntityInline>
{
protected override void Write(NormalizeRenderer renderer, HtmlEntityInline obj)
{
renderer.Write(obj.Original);
}
}
}

View File

@@ -0,0 +1,18 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax.Inlines;
namespace Markdig.Renderers.Normalize.Inlines
{
/// <summary>
/// A Normalize renderer for a <see cref="HtmlInline"/>.
/// </summary>
public class NormalizeHtmlInlineRenderer : NormalizeObjectRenderer<HtmlInline>
{
protected override void Write(NormalizeRenderer renderer, HtmlInline obj)
{
renderer.Write(obj.Tag);
}
}
}

View File

@@ -0,0 +1,81 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using System.Globalization;
using Markdig.Syntax;
namespace Markdig.Renderers.Normalize
{
/// <summary>
/// A Normalize renderer for a <see cref="ListBlock"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.ListBlock}" />
public class ListRenderer : NormalizeObjectRenderer<ListBlock>
{
protected override void Write(NormalizeRenderer renderer, ListBlock listBlock)
{
renderer.EnsureLine();
var compact = renderer.CompactParagraph;
renderer.CompactParagraph = !listBlock.IsLoose;
if (listBlock.IsOrdered)
{
int index = 0;
if (listBlock.OrderedStart != null)
{
switch (listBlock.BulletType)
{
case '1':
int.TryParse(listBlock.OrderedStart, out index);
break;
}
}
foreach (var item in listBlock)
{
var listItem = (ListItemBlock)item;
renderer.EnsureLine();
renderer.Write(index + "");
renderer.Write(listBlock.OrderedDelimiter);
renderer.Write(' ');
renderer.PushIndent(new string(' ', IntLog10Fast(index) + 3));
renderer.WriteChildren(listItem);
renderer.PopIndent();
switch (listBlock.BulletType)
{
case '1':
index++;
break;
}
}
}
else
{
foreach (var item in listBlock)
{
var listItem = (ListItemBlock)item;
renderer.EnsureLine();
renderer.Write("- ");
renderer.PushIndent(" ");
renderer.WriteChildren(listItem);
renderer.PopIndent();
}
}
renderer.CompactParagraph = compact;
renderer.FinishBlock();
}
private static int IntLog10Fast(int input) =>
(input < 10) ? 0 :
(input < 100) ? 1 :
(input < 1000) ? 2 :
(input < 10000) ? 3 :
(input < 100000) ? 4 :
(input < 1000000) ? 5 :
(input < 10000000) ? 6 :
(input < 100000000) ? 7 :
(input < 1000000000) ? 8 : 9;
}
}

View File

@@ -0,0 +1,16 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax;
namespace Markdig.Renderers.Normalize
{
/// <summary>
/// A base class for Normalize rendering <see cref="Block"/> and <see cref="Markdig.Syntax.Inlines.Inline"/> Markdown objects.
/// </summary>
/// <typeparam name="TObject">The type of the object.</typeparam>
/// <seealso cref="Markdig.Renderers.IMarkdownObjectRenderer" />
public abstract class NormalizeObjectRenderer<TObject> : MarkdownObjectRenderer<NormalizeRenderer, TObject> where TObject : MarkdownObject
{
}
}

View File

@@ -0,0 +1,156 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using System;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using Markdig.Helpers;
using Markdig.Renderers.Html;
using Markdig.Syntax;
using Markdig.Renderers.Normalize.Inlines;
namespace Markdig.Renderers.Normalize
{
/// <summary>
/// Default HTML renderer for a Markdown <see cref="MarkdownDocument"/> object.
/// </summary>
/// <seealso cref="Markdig.Renderers.TextRendererBase{Markdig.Renderers.Normalize.NormalizeRenderer}" />
public class NormalizeRenderer : TextRendererBase<NormalizeRenderer>
{
/// <summary>
/// Initializes a new instance of the <see cref="NormalizeRenderer"/> class.
/// </summary>
/// <param name="writer">The writer.</param>
public NormalizeRenderer(TextWriter writer) : base(writer)
{
// Default block renderers
ObjectRenderers.Add(new CodeBlockRenderer());
ObjectRenderers.Add(new ListRenderer());
ObjectRenderers.Add(new HeadingRenderer());
ObjectRenderers.Add(new HtmlBlockRenderer());
ObjectRenderers.Add(new ParagraphRenderer());
ObjectRenderers.Add(new QuoteBlockRenderer());
ObjectRenderers.Add(new ThematicBreakRenderer());
// Default inline renderers
ObjectRenderers.Add(new AutolinkInlineRenderer());
ObjectRenderers.Add(new CodeInlineRenderer());
ObjectRenderers.Add(new DelimiterInlineRenderer());
ObjectRenderers.Add(new EmphasisInlineRenderer());
ObjectRenderers.Add(new LineBreakInlineRenderer());
ObjectRenderers.Add(new NormalizeHtmlInlineRenderer());
ObjectRenderers.Add(new NormalizeHtmlEntityInlineRenderer());
ObjectRenderers.Add(new LinkInlineRenderer());
ObjectRenderers.Add(new LiteralInlineRenderer());
}
public bool CompactParagraph { get; set; }
public void FinishBlock()
{
if (!IsLastInContainer && !CompactParagraph)
{
WriteLine();
WriteLine();
}
}
///// <summary>
///// Writes the attached <see cref="HtmlAttributes"/> on the specified <see cref="MarkdownObject"/>.
///// </summary>
///// <param name="obj">The object.</param>
///// <returns></returns>
//public NormalizeRenderer WriteAttributes(MarkdownObject obj)
//{
// if (obj == null) throw new ArgumentNullException(nameof(obj));
// return WriteAttributes(obj.TryGetAttributes());
//}
///// <summary>
///// Writes the specified <see cref="HtmlAttributes"/>.
///// </summary>
///// <param name="attributes">The attributes to render.</param>
///// <returns>This instance</returns>
//public NormalizeRenderer WriteAttributes(HtmlAttributes attributes)
//{
// if (attributes == null)
// {
// return this;
// }
// if (attributes.Id != null)
// {
// Write(" id=\"").WriteEscape(attributes.Id).Write("\"");
// }
// if (attributes.Classes != null && attributes.Classes.Count > 0)
// {
// Write(" class=\"");
// for (int i = 0; i < attributes.Classes.Count; i++)
// {
// var cssClass = attributes.Classes[i];
// if (i > 0)
// {
// Write(" ");
// }
// WriteEscape(cssClass);
// }
// Write("\"");
// }
// if (attributes.Properties != null && attributes.Properties.Count > 0)
// {
// foreach (var property in attributes.Properties)
// {
// Write(" ").Write(property.Key);
// if (property.Value != null)
// {
// Write("=").Write("\"");
// WriteEscape(property.Value);
// Write("\"");
// }
// }
// }
// return this;
//}
/// <summary>
/// Writes the lines of a <see cref="LeafBlock"/>
/// </summary>
/// <param name="leafBlock">The leaf block.</param>
/// <param name="writeEndOfLines">if set to <c>true</c> write end of lines.</param>
/// <returns>This instance</returns>
public NormalizeRenderer WriteLeafRawLines(LeafBlock leafBlock, bool writeEndOfLines, bool indent = false)
{
if (leafBlock == null) throw new ArgumentNullException(nameof(leafBlock));
if (leafBlock.Lines.Lines != null)
{
var lines = leafBlock.Lines;
var slices = lines.Lines;
for (int i = 0; i < lines.Count; i++)
{
if (!writeEndOfLines && i > 0)
{
WriteLine();
}
if (indent)
{
Write(" ");
}
Write(ref slices[i].Slice);
if (writeEndOfLines)
{
WriteLine();
}
}
}
return this;
}
}
}

View File

@@ -0,0 +1,25 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax;
namespace Markdig.Renderers.Normalize
{
/// <summary>
/// A Normalize renderer for a <see cref="ParagraphBlock"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.ParagraphBlock}" />
public class ParagraphRenderer : NormalizeObjectRenderer<ParagraphBlock>
{
protected override void Write(NormalizeRenderer renderer, ParagraphBlock obj)
{
if (!renderer.CompactParagraph)
{
renderer.EnsureLine();
}
renderer.WriteLeafInline(obj);
renderer.FinishBlock();
}
}
}

View File

@@ -0,0 +1,23 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax;
namespace Markdig.Renderers.Normalize
{
/// <summary>
/// A Normalize renderer for a <see cref="QuoteBlock"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.QuoteBlock}" />
public class QuoteBlockRenderer : NormalizeObjectRenderer<QuoteBlock>
{
protected override void Write(NormalizeRenderer renderer, QuoteBlock obj)
{
renderer.PushIndent(obj.QuoteChar + " ");
renderer.WriteChildren(obj);
renderer.PopIndent();
renderer.FinishBlock();
}
}
}

View File

@@ -0,0 +1,21 @@
// Copyright (c) Alexandre Mutel. All rights reserved.
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using Markdig.Syntax;
namespace Markdig.Renderers.Normalize
{
/// <summary>
/// A Normalize renderer for a <see cref="ThematicBreakBlock"/>.
/// </summary>
/// <seealso cref="Markdig.Renderers.Normalize.NormalizeObjectRenderer{Markdig.Syntax.ThematicBreakBlock}" />
public class ThematicBreakRenderer : NormalizeObjectRenderer<ThematicBreakBlock>
{
protected override void Write(NormalizeRenderer renderer, ThematicBreakBlock obj)
{
renderer.WriteLine(new string(obj.ThematicChar, obj.ThematicCharCount));
renderer.FinishBlock();
}
}
}

View File

@@ -2,6 +2,7 @@
// This file is licensed under the BSD-Clause 2 license.
// See the license.txt file in the project root for more information.
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.CompilerServices;
using Markdig.Helpers;
@@ -70,6 +71,7 @@ namespace Markdig.Renderers
{
private bool previousWasLine;
private char[] buffer;
private readonly List<string> indents;
/// <summary>
/// Initializes a new instance of the <see cref="TextRendererBase{T}"/> class.
@@ -80,6 +82,7 @@ namespace Markdig.Renderers
buffer = new char[1024];
// We assume that we are starting as if we had previously a newline
previousWasLine = true;
indents = new List<string>();
}
/// <summary>
@@ -95,6 +98,31 @@ namespace Markdig.Renderers
return (T)this;
}
public void PushIndent(string indent)
{
if (indent == null) throw new ArgumentNullException(nameof(indent));
indents.Add(indent);
}
public void PopIndent()
{
// TODO: Check
indents.RemoveAt(indents.Count - 1);
}
private void WriteIndent()
{
if (previousWasLine)
{
previousWasLine = false;
for (int i = 0; i < indents.Count; i++)
{
Writer.Write(indents[i]);
}
}
}
/// <summary>
/// Writes the specified content.
/// </summary>
@@ -103,6 +131,7 @@ namespace Markdig.Renderers
[MethodImpl(MethodImplOptionPortable.AggressiveInlining)]
public T Write(string content)
{
WriteIndent();
previousWasLine = false;
Writer.Write(content);
return (T) this;
@@ -142,6 +171,7 @@ namespace Markdig.Renderers
[MethodImpl(MethodImplOptionPortable.AggressiveInlining)]
public T Write(char content)
{
WriteIndent();
previousWasLine = content == '\n';
Writer.Write(content);
return (T) this;
@@ -161,6 +191,7 @@ namespace Markdig.Renderers
return (T) this;
}
WriteIndent();
previousWasLine = false;
if (offset == 0 && content.Length == length)
{
@@ -189,6 +220,7 @@ namespace Markdig.Renderers
[MethodImpl(MethodImplOptionPortable.AggressiveInlining)]
public T WriteLine()
{
WriteIndent();
Writer.WriteLine();
previousWasLine = true;
return (T) this;
@@ -202,6 +234,7 @@ namespace Markdig.Renderers
[MethodImpl(MethodImplOptionPortable.AggressiveInlining)]
public T WriteLine(string content)
{
WriteIndent();
previousWasLine = true;
Writer.WriteLine(content);
return (T) this;

View File

@@ -17,5 +17,9 @@ namespace Markdig.Syntax
public ThematicBreakBlock(BlockParser parser) : base(parser)
{
}
public char ThematicChar { get; set; }
public int ThematicCharCount { get; set; }
}
}