public IMarkdownToken Rewrite(IMarkdownRewriteEngine engine, IMarkdownToken token)
{
foreach (var validator in Validators)
{
validator.Validate(token);
}
return null;
}
public IMarkdownToken Rewrite(IMarkdownRewriteEngine engine, IMarkdownToken token)
{
IMarkdownToken newToken = token;
for (int index = 0; index < Inner.Length; index++)
{
newToken = Inner[index].Rewrite(engine, newToken) ?? newToken;
}
return newToken;
}
private IMarkdownToken RewriteToken(IMarkdownToken token)
{
var rewritedToken = token;
var newToken = Rewriter.Rewrite(this, rewritedToken);
if (newToken != null)
{
rewritedToken = newToken;
}
return rewritedToken;
}
public StringBuffer Render(IMarkdownToken token)
{
try
{
// double dispatch.
return ((dynamic)Renderer).Render((dynamic)this, (dynamic)token, (dynamic)token.Context);
}
catch (RuntimeBinderException ex)
{
throw new InvalidOperationException($"Unable to handle token: {token.GetType().Name}, rule: {token.Rule.Name}", ex);
}
}
public IMarkdownToken Rewrite(MarkdownEngine engine, IMarkdownToken token)
{
if (Rewriters.Count > 0)
{
foreach (var rewriter in Rewriters)
{
var newToken = rewriter.Rewrite(engine, token);
if (newToken != null)
{
return newToken;
}
}
}
return null;
}
public IMarkdownToken Rewrite(IMarkdownRewriteEngine engine, IMarkdownToken token)
{
IMarkdownToken lastToken;
IMarkdownToken newToken = token;
for (int loopCount = 0; loopCount < MaxLoopCount; loopCount++)
{
lastToken = newToken;
newToken = Inner.Rewrite(engine, lastToken);
if (newToken == null)
{
return lastToken;
}
}
throw new InvalidOperationException("Too many loops!");
}
private StringBuffer RenderCore(IMarkdownRenderer render, IMarkdownToken token, IMarkdownContext context)
{
if (!CheckRuleEnabled(token))
{
return(token.SourceInfo.Markdown);
}
if (!NeedMigration(token))
{
return(token.SourceInfo.Markdown);
}
var migrated = _renderer.Render((dynamic)render, (dynamic)token, (dynamic)context);
if (!string.Equals(token.SourceInfo.Markdown.ToString(), migrated.ToString()))
{
_renderer.UpdateReport(token, _renderer.GetTokenName(token));
}
return(migrated);
}
private StringBuffer RenderRefLink(IMarkdownRenderer render, IMarkdownToken token, MarkdownInlineContext context)
{
StringBuffer content = StringBuffer.Empty;
if (token is MarkdownImageInlineToken)
{
var realToken = token as MarkdownImageInlineToken;
content += "![";
if (render.Options.LegacyMode)
{
content += StringHelper.LegacyEscapeMarkdown(realToken.Text);
}
else
{
content += StringHelper.EscapeMarkdown(realToken.Text);
}
content += "][";
content += realToken.RefId;
content += "]";
}
else if (token is MarkdownLinkInlineToken)
{
var realToken = token as MarkdownLinkInlineToken;
content += "[";
foreach (var t in realToken.Content)
{
content += render.Render(t);
}
content += "][";
content += realToken.RefId;
content += "]";
}
else
{
throw new NotSupportedException("Reference link token should be either link token or image token");
}
return(content);
}
private void ValidateOne(IMarkdownToken token, Match m, MarkdownTagValidationRule validator)
{
if (!string.IsNullOrEmpty(validator.CustomValidatorContractName))
{
if (Container == null)
{
Logger.LogWarning($"Unable to validate tag by contract({validator.CustomValidatorContractName}): CompositionHost is null.");
return;
}
var customValidators = GetCustomMarkdownTagValidators(validator);
if (customValidators.Count == 0)
{
Logger.LogWarning($"Cannot find custom markdown tag validator by contract name: {validator.CustomValidatorContractName}.");
return;
}
if (customValidators.TrueForAll(av => av.Validate(token.SourceInfo.Markdown)))
{
return;
}
}
ValidateOneCore(token, m, validator);
}
private bool CheckInlineRuleEnabled(IMarkdownToken token)
{
if (_rule == MigrationRule.All)
{
return(true);
}
if (token is DfmXrefInlineToken && _rule.HasFlag(MigrationRule.Xref))
{
return(true);
}
if (token is DfmIncludeInlineToken && _rule.HasFlag(MigrationRule.InclusionInline))
{
return(true);
}
if (token is MarkdownImageInlineToken && _rule.HasFlag(MigrationRule.Image))
{
return(true);
}
if (token is MarkdownLinkInlineToken link && _rule.HasFlag(MigrationRule.Link) &&
link.LinkType == MarkdownLinkType.NormalLink)
{
return(true);
}
if (token is MarkdownStrongInlineToken && _rule.HasFlag(MigrationRule.Strong))
{
return(true);
}
if (token is MarkdownEmInlineToken && _rule.HasFlag(MigrationRule.Em))
{
return(true);
}
if (token is MarkdownTableBlockToken && _rule.HasFlag(MigrationRule.Table))
{
return(true);
}
return(false);
}
public void Validate(IMarkdownToken token)
{
var text = GetTokenText(token);
if (string.IsNullOrEmpty(text))
{
return;
}
var m = OpeningTag.Match(text);
bool isOpeningTag = true;
if (m.Length == 0)
{
m = ClosingTag.Match(text);
if (m.Length == 0)
{
return;
}
isOpeningTag = false;
}
ValidateCore(token, m, isOpeningTag);
}
private static void AggregateCore(
MarkdownHeadingBlockToken headToken,
IMarkdownTokenAggregateContext context,
int offset,
List <DfmTabItemBlockToken> items,
IMarkdownToken terminator)
{
var md = items.Aggregate(StringBuffer.Empty, (s, t) => s + t.SourceInfo.Markdown);
if (terminator != null)
{
md += terminator.SourceInfo.Markdown;
offset++;
}
context.AggregateTo(
new DfmTabGroupBlockToken(
DfmTabGroupBlockRule.Instance,
headToken.Context,
Guid.NewGuid().ToString(),
items.ToImmutableArray(),
0,
headToken.SourceInfo.Copy(md.ToString())),
offset);
}
public StringBuffer Render(IMarkdownRenderer renderer, IMarkdownToken token, IMarkdownContext context)
{
return(BaseRender(renderer, token, context));
}
private string ExposeTokenNameInDfm(IMarkdownToken token)
{
var tokenName = ExposeTokenName(token);
tokenName = TrimStringStart(tokenName, "Dfm");
return tokenName;
}
private StringBuffer RenderNumberLink(IMarkdownRenderer render, IMarkdownToken token, MarkdownInlineContext context)
{
StringBuffer content = StringBuffer.Empty;
if(token is MarkdownImageInlineToken)
{
var realToken = token as MarkdownImageInlineToken;
content += "![";
content += realToken.Text;
content += "]";
}
else if(token is MarkdownLinkInlineToken)
{
var realToken = token as MarkdownLinkInlineToken;
content += "[";
foreach (var t in realToken.Content)
{
content += render.Render(t);
}
content += "]";
}
else
{
throw new NotSupportedException("Number link token should be either link token or image token");
}
return content;
}
public DfmSectionBlockSplitToken(IMarkdownToken token) : base(token)
{
}
public DfmNoteBlockSplitToken(IMarkdownToken token) : base(token)
{
}
protected static StringBuffer AppendSourceInfo(StringBuffer result, IMarkdownRenderer renderer, IMarkdownToken token)
{
if (renderer.Options.ShouldExportSourceInfo)
{
result = AppendSourceInfoCore(result, token);
}
return(result);
}
public static StringBuffer AppendSourceInfo(StringBuffer result, Options options, IMarkdownToken token)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (token == null)
{
throw new ArgumentNullException(nameof(token));
}
if (options.ShouldExportSourceInfo)
{
result = AppendSourceInfoCore(result, token);
}
return(result);
}
public IMarkdownToken Rewrite(IMarkdownRewriteEngine engine, IMarkdownToken token)
{
return null;
}
public StringBuffer Render(IMarkdownToken token)
{
return(this.Render((dynamic)this, (dynamic)token, (dynamic)token.Context));
}
public DfmDefaultBlockQuoteBlockSplitToken(IMarkdownToken token) : base(token)
{
}
internal void SetToken(int index, IMarkdownToken token)
{
EnsureWrite();
_tokens[index] = token;
}
public MarkdownTokenAggregateContext(IMarkdownToken parentToken, ImmutableArray <IMarkdownToken> tokens)
{
ParentToken = parentToken;
_sourceTokens = tokens;
}
public virtual StringBuffer Render(IMarkdownRenderer renderer, IMarkdownToken token, IMarkdownContext context)
{
return(StringBuffer.Empty);
}
public StringBuffer BaseRender(IMarkdownRenderer renderer, IMarkdownToken token, IMarkdownContext context)
{
// double dispatch.
return(((dynamic)_innerRenderer).Render((dynamic)renderer, (dynamic)token, (dynamic)context));
}
public virtual StringBuffer Render(IMarkdownRenderer render, IMarkdownToken token, IMarkdownContext context)
{
return token.RawMarkdown;
}
public IMarkdownToken Rewrite(IMarkdownRewriteEngine engine, IMarkdownToken token)
{
return(null);
}
StringBuffer IDfmCustomizedRendererPart.Render(IMarkdownRenderer renderer, IMarkdownToken token, IMarkdownContext context)
{
return(Render((TRenderer)renderer, (TToken)token, (TContext)context));
}
private static StringBuffer AppendSourceInfoCore(StringBuffer result, IMarkdownToken token)
{
return(result + " sourceFile=\"" + StringHelper.HtmlEncode(token.SourceInfo.File) + "\" sourceStartLineNumber=\"" + token.SourceInfo.LineNumber.ToString() + "\" sourceEndLineNumber=\"" + (token.SourceInfo.LineNumber + token.SourceInfo.ValidLineCount - 1).ToString() + "\"");
}
public virtual StringBuffer Render(IMarkdownRenderer render, IMarkdownToken token, IMarkdownContext context)
{
return(token.RawMarkdown);
}
public SplitToken(IMarkdownToken token)
{
Token = token;
InnerTokens = new List <IMarkdownToken>();
}
protected string ExposeTokenName(IMarkdownToken token)
{
var tokenName = token.GetType().Name;
tokenName = TrimStringStart(tokenName, "Markdown");
tokenName = TrimStringStart(tokenName, "Gfm");
tokenName = TrimStringEnd(tokenName, "Token");
tokenName = TrimStringEnd(tokenName, "Block");
tokenName = TrimStringEnd(tokenName, "Inline");
return tokenName;
}
bool IDfmCustomizedRendererPart.Match(IMarkdownRenderer renderer, IMarkdownToken token, IMarkdownContext context)
{
return(Match((TRenderer)renderer, (TToken)token, (TContext)context));
}
private StringBuffer MarkupInlineToken(IMarkdownRenderer render, IMarkdownToken token)
{
return(_dfmHtmlRender.Render((dynamic)render, (dynamic)token, (dynamic)token.Context));
}
private static IEnumerable <IMarkdownToken> ChildrenCore(IMarkdownToken token) => (token as IMarkdownExpression)?.GetChildren() ?? Enumerable.Empty <IMarkdownToken>();
private bool CheckRuleEnabled(IMarkdownToken token)
{
if (_rule == MigrationRule.All)
{
return(true);
}
if (token is DfmXrefInlineToken && _rule.HasFlag(MigrationRule.Xref))
{
return(true);
}
if (token is DfmIncludeInlineToken && _rule.HasFlag(MigrationRule.InclusionInline))
{
return(true);
}
if (token is MarkdownImageInlineToken && _rule.HasFlag(MigrationRule.Image))
{
return(true);
}
if (token is MarkdownLinkInlineToken && _rule.HasFlag(MigrationRule.Link))
{
return(true);
}
if (token is MarkdownStrongInlineToken && _rule.HasFlag(MigrationRule.Strong))
{
return(true);
}
if (token is MarkdownEmInlineToken && _rule.HasFlag(MigrationRule.Em))
{
return(true);
}
if (token is MarkdownTableBlockToken && _rule.HasFlag(MigrationRule.Table))
{
return(true);
}
if (token is DfmNoteBlockToken && _rule.HasFlag(MigrationRule.Note))
{
return(true);
}
if (token is DfmIncludeBlockToken && _rule.HasFlag(MigrationRule.InclusionBlock))
{
return(true);
}
if (token is DfmFencesBlockToken && _rule.HasFlag(MigrationRule.Code))
{
return(true);
}
if (token is MarkdownHtmlBlockToken && _rule.HasFlag(MigrationRule.HtmlBlock))
{
return(true);
}
if (token is MarkdownHeadingBlockToken && _rule.HasFlag(MigrationRule.Heading))
{
return(true);
}
if (token is MarkdownListBlockToken && _rule.HasFlag(MigrationRule.List))
{
return(true);
}
if (token is MarkdownBlockquoteBlockToken && _rule.HasFlag(MigrationRule.BlockQuote))
{
return(true);
}
if (token is MarkdownParagraphBlockToken && (_rule & MigrationRule.Paragraph) != 0)
{
return(true);
}
if (token is MarkdownNonParagraphBlockToken && (_rule & MigrationRule.Paragraph) != 0)
{
return(true);
}
return(false);
}
private static IEnumerable <IMarkdownToken> DescendantsCore(IMarkdownToken token) =>
from child in ChildrenCore(token)
from item in new[] { child }.Concat(DescendantsCore(child))
select item;
public override StringBuffer Render(IMarkdownRenderer render, IMarkdownToken token, IMarkdownContext context)
{
return(token.SourceInfo.Markdown);
}
protected static StringBuffer AppendSourceInfo(StringBuffer result, IMarkdownRenderer renderer, IMarkdownToken token)
{
if (renderer.Options.ShouldExportSourceInfo)
{
result = result + " sourceFile=\"" + StringHelper.HtmlEncode(token.SourceInfo.File) + "\" sourceStartLineNumber=\"" + token.SourceInfo.LineNumber.ToString() + "\" sourceEndLineNumber=\"" + (token.SourceInfo.LineNumber + token.SourceInfo.ValidLineCount - 1).ToString() + "\"";
}
return(result);
}
protected StringBuffer Insert(IMarkdownToken token, StringBuffer name, StringBuffer tokenContent = null)
{
// TODO: separate the name to extra properties
int startLineNumber = token.SourceInfo.LineNumber;
int endLineNumber = (token.SourceInfo.ValidLineCount > 0) ? (startLineNumber + token.SourceInfo.ValidLineCount - 1) : startLineNumber;
return Insert(startLineNumber, endLineNumber, name, tokenContent);
}
public SplitToken(IMarkdownToken token)
{
Token = token;
InnerTokens = new List<IMarkdownToken>();
}
public DfmVideoBlockSplitToken(IMarkdownToken token) : base(token)
{
}
