public override async Task Generate(DirectoryInfo directory, ProgrammableBlockApi api)
{
var fileName = Path.Combine(directory.FullName, "Namespace-Index.md");
using (var file = File.CreateText(fileName))
{
var writer = new MarkdownWriter(file);
await writer.BeginParagraphAsync();
await writer.WriteAsync($"← {MarkdownInline.HRef("Index", "Api-Index")}");
await writer.EndParagraphAsync();
await writer.WriteHeaderAsync(3, "Assemblies");
await writer.BeginParagraphAsync();
await writer.WriteLineAsync("These are the game assemblies used by programmable block scripts.");
await writer.WriteLineAsync();
foreach (var assembly in api.Entries.Select(e => e.AssemblyName).Distinct().OrderBy(n => n))
await writer.WriteLineAsync($"{assembly}.dll ");
await writer.EndParagraphAsync();
await writer.WriteHeaderAsync(3, "Types");
await writer.BeginParagraphAsync();
await writer.WriteAsync("This index contains all types and members available to ingame scripting - with exception to the .NET types, because including those would have made the listing far too big. There will be links to Microsoft's own documentation for those types where appropriate.");
await writer.EndParagraphAsync();
foreach (var blockGroup in api.Entries.Where(e => e.Member is Type).GroupBy(e => e.Member.GetNamespace()).OrderBy(g => g.Key))
{
await writer.WriteHeaderAsync(3, blockGroup.Key);
await writer.BeginParagraphAsync();
foreach (var type in blockGroup.OrderBy(e => e.ToString(ApiEntryStringFlags.ShortDisplayName | ApiEntryStringFlags.DeclaringTypes)))
await writer.WriteLineAsync(MemberGenerator.LinkTo(WebUtility.HtmlEncode(type.ToString(ApiEntryStringFlags.ShortDisplayName | ApiEntryStringFlags.DeclaringTypes)), type));
await writer.EndParagraphAsync();
}
await writer.FlushAsync();
}
}
private string GetMarkdownInline(MarkdownInline inline)
{
if (inline == null)
{
return("");
}
switch (inline.Type)
{
case MarkdownInlineType.TextRun:
return(GetCustomBlock(inline.ToString()));
case MarkdownInlineType.MarkdownLink:
var linkLine = (MarkdownLinkInline)inline;
return($"<a href='{linkLine.Url}' target='_blank'>{GetMarkdownInlines(linkLine.Inlines)}</a>");
case MarkdownInlineType.Italic:
var italiicLine = (ItalicTextInline)inline;
return($"<span class='md-italic'>{GetMarkdownInlines(italiicLine.Inlines)}</a>");
case MarkdownInlineType.Bold:
var boldLine = (BoldTextInline)inline;
return($"<span class='md-bold'>{GetMarkdownInlines(boldLine.Inlines)}</a>");
case MarkdownInlineType.Code:
var codeLine = (CodeInline)inline;
return($"<div class='md-code'>{GetCustomBlock(codeLine.Text)}</div>");
default:
return(GetCustomBlock(inline.ToString()));
}
}
//static bool IsMsType(MemberInfo memberInfo)
//{
// var assembly = memberInfo.GetAssembly();
// if (assembly.GetName().Name == "mscorlib")
// return true;
// var companyAttribute = assembly.GetCustomAttribute<AssemblyCompanyAttribute>();
// if (companyAttribute?.Company == "Microsoft Corporation")
// return true;
// return false;
//}
public static string LinkTo(string text, ApiEntry entry)
{
if (ShouldBeIgnored(entry))
{
return(text);
}
if (MicrosoftLink.IsMsType(entry.Member))
{
var type = entry.Member as Type;
var fullName = entry.FullName;
if (type != null)
{
if (type.IsGenericType && !type.IsGenericTypeDefinition)
{
type = type.GetGenericTypeDefinition();
}
fullName = type.FullName?.Replace('`', '-');
}
return(MarkdownInline.HRef(text, $"https://docs.microsoft.com/en-us/dotnet/api/{fullName}?view=netframework-4.6"));
}
return(MarkdownInline.HRef(text, Path.GetFileNameWithoutExtension(entry.SuggestedFileName)));
}
/// <summary>
/// Inline processing
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
protected string ProcessInline(MarkdownInline i)
{
string para = string.Empty;
switch (i.Type)
{
//case MarkdownInlineType.Comment:
// break;
//case MarkdownInlineType.TextRun:
// break;
case MarkdownInlineType.Bold:
para += ANSI.WriteMode(ANSICodes.Modes.Bold) +
i.ToString().Trim('*') + ANSI.WriteMode();
break;
//case MarkdownInlineType.Italic:
// break;
case MarkdownInlineType.MarkdownLink:
MarkdownLinkInline mitLink = (MarkdownLinkInline)i;
if (mitLink.Url.ToLower().EndsWith(".md"))
{
actionsCount++;
para += $"{mitLink.Inlines[0]}[{actionsCount}]";
Data.Actions.Add(actionsCount.ToString(),
new BBSCodeResult.Action()
{
module = "MarkdownScreen",
data = (mitLink.Url.StartsWith("http") ? "" : basePath) + mitLink.Url
});
}
else
{
para += mitLink.ToString();
}
break;
//case MarkdownInlineType.RawHyperlink:
// break;
//case MarkdownInlineType.RawSubreddit:
// break;
//case MarkdownInlineType.Strikethrough:
// break;
//case MarkdownInlineType.Superscript:
// break;
//case MarkdownInlineType.Subscript:
// break;
//case MarkdownInlineType.Code:
// break;
//case MarkdownInlineType.Image:
// break;
//case MarkdownInlineType.Emoji:
// break;
//case MarkdownInlineType.LinkReference:
// break;
default:
para += i.ToString();
break;
}
return(para);
}
static SpanInline GetInlineTextWithFlags(MarkdownInline inline, SpanInline accum = null)
{
accum ??= new SpanInline();
switch (inline)
{
case TextRunInline textRun:
accum.Text = textRun.Text;
return(accum);
case BoldTextInline bold:
accum.IsBold = true;
return(GetInlineTextWithFlags(bold.Inlines.First(), accum));
case ItalicTextInline italic:
accum.IsItalic = true;
return(GetInlineTextWithFlags(italic.Inlines.First(), accum));
case MarkdownLinkInline link:
accum.Link = link.Url;
return(GetInlineTextWithFlags(link.Inlines.First(), accum));
default:
return(null);
}
}
/// <summary>
/// Called to render an inline element
/// </summary>
/// <param name="element"></param>
/// <param name="currentInlines"></param>
private void RendnerInline(MarkdownInline element, InlineCollection currentInlines, ref bool trimTextStart)
{
switch (element.Type)
{
case MarkdownInlineType.TextRun:
RenderTextRun((TextRunInline)element, currentInlines, ref trimTextStart);
break;
case MarkdownInlineType.Bold:
RenderBoldRun((BoldTextElement)element, currentInlines, ref trimTextStart);
break;
case MarkdownInlineType.MarkdownLink:
RenderMarkdownLink((MarkdownLinkInline)element, currentInlines, ref trimTextStart);
break;
case MarkdownInlineType.Italic:
RenderItalicRun((ItalicTextElement)element, currentInlines, ref trimTextStart);
break;
case MarkdownInlineType.RawHyperlink:
RenderRawHyperlink((RawHyperlinkInline)element, currentInlines, ref trimTextStart);
break;
case MarkdownInlineType.RawSubreddit:
RenderRawSubreddit((RawSubredditInline)element, currentInlines, ref trimTextStart);
break;
}
}
async Task GenerateNamespaceDoc(DirectoryInfo directory, IGrouping <string, ApiEntry> ns)
{
var fileName = Path.Combine(directory.FullName, ToMdFileName(ns.Key));
using (var file = File.CreateText(fileName))
{
var writer = new MarkdownWriter(file);
await writer.BeginParagraphAsync();
await writer.WriteAsync($"← {MarkdownInline.HRef("Index", "Api-Index")} ← {MarkdownInline.HRef("Namespace Index", "Namespace-Index")}");
await writer.EndParagraphAsync();
await writer.WriteHeaderAsync(1, ns.Key);
await writer.BeginParagraphAsync();
foreach (var typeGroup in ns.GroupBy(e => e.DeclaringEntry ?? e).OrderBy(g => g.Key.FullName))
{
await writer.WriteLineAsync(MarkdownInline.Strong(MemberGenerator.LinkTo(typeGroup.Key.Name, typeGroup.Key)));
}
await writer.EndParagraphAsync();
await writer.FlushAsync();
}
}
private void RenderInline(MarkdownInline inline, InlineCollection inlineCollection)
{
switch (inline.Type)
{
case MarkdownInlineType.TextRun:
RenderTextRun((TextRunInline)inline, inlineCollection);
break;
}
}
protected override string StringRepresentation()
{
if (Inlines == null)
{
return(string.Empty);
}
return($"{new string('#', this.HeaderLevel)} {MarkdownInline.ToString(Inlines)}");
}
async Task WriteTable(string title, IEnumerable <ApiEntry> entries, ProgrammableBlockApi api, ApiEntry entry, MarkdownWriter writer)
{
var items = entries.ToList();
if (items.Count == 0)
{
return;
}
await writer.WriteHeaderAsync(4, title);
await writer.BeginTableAsync("Member", "Description");
foreach (var item in items)
{
await writer.BeginTableCellAsync();
await writer.WriteAsync(MemberGenerator.LinkTo(item.ToString(ApiEntryStringFlags.ParameterTypes), item));
await writer.EndTableCellAsync();
await writer.BeginTableCellAsync();
var obsoleteAttribute = item.Member.GetCustomAttribute <ObsoleteAttribute>(false);
if (obsoleteAttribute != null)
{
await writer.BeginParagraphAsync();
if (string.IsNullOrWhiteSpace(obsoleteAttribute.Message))
{
await writer.WriteAsync(MarkdownInline.Emphasized(MarkdownInline.Strong("Obsolete")));
}
else
{
await writer.WriteAsync(MarkdownInline.Emphasized($"{MarkdownInline.Strong("Obsolete:")} {obsoleteAttribute.Message}"));
}
await writer.EndParagraphAsync();
}
var context = new XmlDocWriteContext(key => ResolveTypeReference(api, key));
item.Documentation?.Summary?.WriteMarkdown(context, writer);
if (entry != item.DeclaringEntry)
{
await writer.BeginParagraphAsync();
await writer.WriteAsync(MarkdownInline.Emphasized($"Inherited from {MemberGenerator.LinkTo(item.DeclaringEntry.ToString(ApiEntryStringFlags.ShortDisplayName), item.DeclaringEntry)}"));
await writer.EndParagraphAsync();
}
await writer.EndTableCellAsync();
}
await writer.EndTableAsync();
}
/// <summary>
/// Called to render an inline element.
/// </summary>
/// <param name="element"> The parsed inline element to render. </param>
/// <param name="context"> Persistent state. </param>
protected void RenderInline(MarkdownInline element, IRenderContext context)
{
switch (element.Type)
{
case MarkdownInlineType.TextRun:
RenderTextRun((TextRunInline)element, context);
break;
case MarkdownInlineType.Italic:
RenderItalicRun((ItalicTextInline)element, context);
break;
case MarkdownInlineType.Bold:
RenderBoldRun((BoldTextInline)element, context);
break;
case MarkdownInlineType.MarkdownLink:
CheckRenderMarkdownLink((MarkdownLinkInline)element, context);
break;
case MarkdownInlineType.RawHyperlink:
RenderHyperlink((HyperlinkInline)element, context);
break;
case MarkdownInlineType.Strikethrough:
RenderStrikethroughRun((StrikethroughTextInline)element, context);
break;
case MarkdownInlineType.Superscript:
RenderSuperscriptRun((SuperscriptTextInline)element, context);
break;
case MarkdownInlineType.Subscript:
RenderSubscriptRun((SubscriptTextInline)element, context);
break;
case MarkdownInlineType.Code:
RenderCodeRun((CodeInline)element, context);
break;
case MarkdownInlineType.Image:
RenderImage((ImageInline)element, context);
break;
case MarkdownInlineType.Emoji:
RenderEmoji((EmojiInline)element, context);
break;
case MarkdownInlineType.Other:
RenderOtherRun(element, context);
break;
}
}
/// <summary>
/// Called to render an inline element.
/// </summary>
/// <param name="element"> The parsed inline element to render. </param>
/// <param name="context"> Persistent state. </param>
protected void RenderInline(MarkdownInline element, IRenderContext context)
{
switch (element.Type)
{
case MarkdownInlineType.TextRun:
RenderTextRun((TextRunInline)element, context);
break;
case MarkdownInlineType.Underline:
RenderUnderlineRun((UnderlineTextInline)element, context);
break;
case MarkdownInlineType.Italic:
RenderItalicRun((ItalicTextInline)element, context);
break;
case MarkdownInlineType.Bold:
RenderBoldRun((BoldTextInline)element, context);
break;
case MarkdownInlineType.MarkdownLink:
CheckRenderMarkdownLink((MarkdownLinkInline)element, context);
break;
case MarkdownInlineType.RawHyperlink:
RenderHyperlink((HyperlinkInline)element, context);
break;
case MarkdownInlineType.Strikethrough:
RenderStrikethroughRun((StrikethroughTextInline)element, context);
break;
case MarkdownInlineType.Spoiler:
RenderSpoiler((SpoilerTextInline)element, context);
break;
case MarkdownInlineType.Code:
RenderCodeRun((CodeInline)element, context);
break;
case MarkdownInlineType.Image:
RenderImage((ImageInline)element, context);
break;
case MarkdownInlineType.Emoji:
RenderEmoji((EmojiInline)element, context);
break;
case MarkdownInlineType.Discord:
RenderDiscord((DiscordInline)element, context);
break;
}
}
async Task WriteInheritors(ApiEntry entry, MarkdownWriter writer)
{
await writer.BeginParagraphAsync();
await writer.WriteLineAsync(MarkdownInline.Strong("Inheritors: "));
foreach (var iface in entry.InheritorEntries)
{
await writer.WriteUnorderedListItemAsync(MemberGenerator.LinkTo(iface.ToString(ApiEntryStringFlags.ShortDisplayName), iface));
}
await writer.EndParagraphAsync();
}
async Task WriteInheritance(ApiEntry entry, MarkdownWriter writer)
{
await writer.BeginParagraphAsync();
await writer.WriteAsync(MarkdownInline.Strong("Inheritance: "));
await writer.WriteAsync(" ");
await writer.WriteLineAsync(string.Join(" ˃ ", AncestorsOf(entry).Reverse()));
await writer.EndParagraphAsync();
}
public static string ToHtml(this MarkdownInline inline, bool keepComments = false)
{
if (inline is ImageInline image)
{
return($"<img src=\"{image.Url}\" alt=\"{image.Tooltip}\" id=\"{image.ReferenceId}\"/>");
}
if (inline is CodeInline code)
{
return($"<code>{code.Text}</code>");
}
if (inline is BoldTextInline bold)
{
return($"<b>{bold.Inlines.ToHtml().TrimStart().TrimEnd()}</b>");
}
if (inline is ItalicTextInline italc)
{
return($"<em>{italc.Inlines.ToHtml().TrimStart().TrimEnd()}</em>");
}
if (inline is StrikethroughTextInline strikethrough)
{
return($"<strike>{strikethrough.Inlines.ToHtml().TrimStart().TrimEnd()}</strike>");
}
if (inline is HyperlinkInline hyperlink)
{
return($"<a href=\"{hyperlink.Url}\" data-type=\"{hyperlink.LinkType}\">{hyperlink.Text}</a>");
}
if (inline is MarkdownLinkInline link)
{
return($"<a href=\"{link.Url}\">{link.Inlines.ToHtml().TrimEnd()}</a>");
}
if (inline is EmojiInline emoji)
{
return($"<i>{emoji.Text}</i>");
}
if (inline is TextRunInline text)
{
return(text.Text);
}
if (inline is SuperscriptTextInline superscript)
{
return($"<sup>{superscript.Inlines.ToHtml().TrimStart().TrimEnd()}</sup>");
}
if (inline is SubscriptTextInline subscript)
{
return($"<sub>{subscript.Inlines.ToHtml().TrimStart().TrimEnd()}</sub>");
}
if (!keepComments && inline.Type == MarkdownInlineType.Comment)
{
return("");
}
return(inline.ToString());
}
public static string LinkTo(string text, ApiEntry entry)
{
if (ShouldBeIgnored(entry))
{
return(text);
}
if (IsMsType(entry.Member))
{
return(MarkdownInline.HRef(text, $"https://docs.microsoft.com/en-us/dotnet/api/{entry.FullName.ToLower()}?view=netframework-4.6"));
}
return(MarkdownInline.HRef(text, Path.GetFileNameWithoutExtension(entry.SuggestedFileName)));
}
async Task GeneratePage(ProgrammableBlockApi api, DirectoryInfo directory, IGrouping <string, ApiEntry> entries)
{
var fileName = Path.Combine(directory.FullName, entries.Key);
using (var file = File.CreateText(fileName))
{
var writer = new MarkdownWriter(file);
var firstEntry = entries.First();
await writer.BeginParagraphAsync();
await writer.WriteAsync($"← {MarkdownInline.HRef("Index", "Api-Index")} ← {MarkdownInline.HRef("Namespace Index", "Namespace-Index")} ← {LinkTo(firstEntry.DeclaringEntry.ToString(ApiEntryStringFlags.ShortDisplayName), firstEntry.DeclaringEntry)}");
await writer.EndParagraphAsync();
foreach (var overload in entries)
{
await writer.WriteHeaderAsync(3, "Summary");
switch (overload.Member)
{
case ConstructorInfo constructorInfo:
await WriteConstructor(api, overload, writer, constructorInfo);
break;
case FieldInfo fieldInfo:
await WriteField(api, overload, writer, fieldInfo);
break;
case PropertyInfo propertyInfo:
await WriteProperty(api, overload, writer, propertyInfo);
break;
case EventInfo eventInfo:
await WriteEvent(api, overload, writer, eventInfo);
break;
case MethodInfo methodInfo:
await WriteMethod(api, overload, writer, methodInfo);
break;
}
}
await writer.FlushAsync();
}
}
public override async Task WriteMarkdown(XmlDocWriteContext context, MarkdownWriter writer)
{
await writer.WriteAsync(" ");
var entry = context.ResolveReference(TextValue);
if (entry.Key == null)
{
await writer.WriteAsync(entry.Value ?? TextValue);
}
else
{
await writer.WriteAsync(MarkdownInline.HRef(entry.Value, entry.Key));
}
await writer.WriteAsync(" ");
}
/// <summary>
/// Called to render an inline element.
/// </summary>
/// <param name="inlineCollection"> The list to add to.</param>
/// <param name="element"> The parsed inline element to render.</param>
/// <param name="parent"> The container element.</param>
/// <param name="context"> Persistent state.</param>
private void RenderInline(InlineCollection inlineCollection, MarkdownInline element, TextElement parent, RenderContext context, bool largeemojis, bool mixedlarge = false)
{
switch (element.Type)
{
case MarkdownInlineType.TextRun:
RenderTextRun(inlineCollection, (TextRunInline)element, context, largeemojis);
break;
case MarkdownInlineType.Italic:
RenderItalicRun(inlineCollection, (ItalicTextInline)element, context);
break;
case MarkdownInlineType.Bold:
RenderBoldRun(inlineCollection, (BoldTextInline)element, context);
break;
case MarkdownInlineType.MarkdownLink:
RenderMarkdownLink(inlineCollection, (MarkdownLinkInline)element, parent, context);
break;
case MarkdownInlineType.Emoji:
RenderEmoji(inlineCollection, (EmojiInline)element, parent, context, largeemojis, mixedlarge);
break;
case MarkdownInlineType.RawHyperlink:
RenderHyperlink(inlineCollection, (HyperlinkInline)element, context);
break;
case MarkdownInlineType.Strikethrough:
RenderStrikethroughRun(inlineCollection, (StrikethroughTextInline)element, parent, context);
break;
case MarkdownInlineType.Code:
RenderCodeRun(inlineCollection, (CodeInline)element, context);
break;
case MarkdownInlineType.Image:
RenderImage(inlineCollection, (ImageInline)element, context);
break;
case MarkdownInlineType.Underline:
RenderUnderlineRun(inlineCollection, (UnderlineTextInline)element, context);
break;
}
}
async Task WriteTypeDefinitions(ApiEntry entry, MarkdownWriter writer)
{
var defs = _typeDefinitions.Definitions.Where(d => d.TypeName == entry.FullName).ToList();
if (!defs.Any())
{
return;
}
await writer.BeginParagraphAsync();
await writer.WriteLineAsync(MarkdownInline.Strong("Type Definitions: "));
foreach (var definition in defs)
{
await writer.WriteUnorderedListItemAsync($"`{definition}`");
}
await writer.EndParagraphAsync();
}
/// <summary>
/// Called to render an inline element.
/// </summary>
/// <param name="inlineCollection"> The list to add to. </param>
/// <param name="element"> The parsed inline element to render. </param>
/// <param name="parent"> The container element. </param>
/// <param name="context"> Persistent state. </param>
private void RenderInline(InlineCollection inlineCollection, MarkdownInline element, TextElement parent, RenderContext context)
{
switch (element.Type)
{
case MarkdownInlineType.TextRun:
RenderTextRun(inlineCollection, (TextRunInline)element, context);
break;
case MarkdownInlineType.Italic:
RenderItalicRun(inlineCollection, (ItalicTextInline)element, context);
break;
case MarkdownInlineType.Bold:
RenderBoldRun(inlineCollection, (BoldTextInline)element, context);
break;
case MarkdownInlineType.MarkdownLink:
RenderMarkdownLink(inlineCollection, (MarkdownLinkInline)element, parent, context);
break;
case MarkdownInlineType.RawHyperlink:
RenderHyperlink(inlineCollection, (HyperlinkInline)element, context);
break;
case MarkdownInlineType.Strikethrough:
RenderStrikethroughRun(inlineCollection, (StrikethroughTextInline)element, context);
break;
case MarkdownInlineType.Superscript:
RenderSuperscriptRun(inlineCollection, (SuperscriptTextInline)element, parent, context);
break;
case MarkdownInlineType.Code:
RenderCodeRun(inlineCollection, (CodeInline)element, context);
break;
case MarkdownInlineType.Discord:
RenderDiscord(inlineCollection, (DiscordInline)element, context);
break;
}
}
async Task WriteInheritors(ApiEntry entry, MarkdownWriter writer)
{
await writer.BeginParagraphAsync();
await writer.WriteLineAsync(MarkdownInline.Strong("Inheritors: "));
var lines = entry.InheritorEntries.Select(iface => new
{
Text = iface.ToString(ApiEntryStringFlags.ShortDisplayName),
Interface = iface
})
.OrderBy(o => o.Text)
.Select(o => MemberGenerator.LinkTo(o.Text, o.Interface))
.ToList();
foreach (var line in lines)
{
await writer.WriteUnorderedListItemAsync(line);
}
await writer.EndParagraphAsync();
}
public List <string> GetReferencedDocuments()
{
var referencedDocuments = new List <string>();
foreach (var block in _markdown.Blocks)
{
var inlines = new MarkdownInline[0];
switch (block)
{
case ParagraphBlock paragraph:
inlines = paragraph.Inlines.ToArray();
break;
case TableBlock table:
inlines = table.Rows
.SelectMany(row => row.Cells)
.SelectMany(cell => cell.Inlines)
.ToArray();
break;
}
foreach (var inline in inlines)
{
if (!(inline is MarkdownLinkInline mdLink))
{
continue;
}
var url = mdLink.Url;
if (url == null)
{
Console.WriteLine($"{_fileName}: Link without URL {mdLink.ReferenceId}");
continue;
}
referencedDocuments.Add(url);
}
}
return(referencedDocuments);
}
async Task WriteTypeDefinitions(ApiEntry entry, MarkdownWriter writer)
{
var defs = _typeDefinitions.Definitions.Where(d => d.TypeName == entry.FullName).ToList();
if (!defs.Any())
{
return;
}
await writer.BeginParagraphAsync();
await writer.WriteLineAsync(MarkdownInline.Strong("Type Definitions: "));
var lines = defs.Select(d => d.ToString())
.OrderBy(o => o)
.ToList();
foreach (var line in lines)
{
await writer.WriteUnorderedListItemAsync(line);
}
await writer.EndParagraphAsync();
}
/// <summary>
/// Initializes a new instance of the <see cref="InlineParseResult"/> class.
/// </summary>
/// <param name="parsedElement">The <see cref="MarkdownInline"/>.</param>
/// <param name="start">The index the inline begins at.</param>
/// <param name="end">The index the inline ends at.</param>
public InlineParseResult(MarkdownInline parsedElement, int start, int end)
{
ParsedElement = parsedElement;
Start = start;
End = end;
}
async Task GeneratePage(ProgrammableBlockApi api, DirectoryInfo directory, ApiEntry entry)
{
var fileName = Path.Combine(directory.FullName, entry.SuggestedFileName);
Debug.WriteLine(entry.FullName + " " + fileName);
using (var file = File.CreateText(fileName))
{
var writer = new MarkdownWriter(file);
await writer.BeginParagraphAsync();
await writer.WriteAsync($"← {MarkdownInline.HRef("Index", "Api-Index")} ← {MarkdownInline.HRef("Namespace Index", "Namespace-Index")}");
await writer.EndParagraphAsync();
await writer.WriteHeaderAsync(4, $"{WebUtility.HtmlEncode(entry.ToString(ApiEntryStringFlags.GenericParameters))} {ConstructOf(entry)}");
await writer.BeginCodeBlockAsync();
await writer.WriteLineAsync(entry.ToString(ApiEntryStringFlags.Modifiers | ApiEntryStringFlags.GenericParameters | ApiEntryStringFlags.Inheritance));
await writer.EndCodeBlockAsync();
if (entry.Documentation?.Summary != null)
{
await WriteDocumentation(api, entry.Documentation?.Summary, writer);
}
await writer.BeginParagraphAsync();
await writer.WriteLineAsync($"{MarkdownInline.Strong("Namespace:")} {MarkdownInline.HRef(entry.NamespaceName, Path.GetFileNameWithoutExtension(ToMdFileName(entry.NamespaceName)))}");
await writer.WriteLineAsync($"{MarkdownInline.Strong("Assembly:")} {entry.AssemblyName}.dll");
await writer.EndParagraphAsync();
if (entry.BaseEntry != null)
{
await WriteInheritance(entry, writer);
}
if (entry.InheritedEntries.Count > 0)
{
await WriteInterfaces(entry, writer);
}
if (entry.InheritorEntries.Count > 0)
{
await WriteInheritors(entry, writer);
}
await WriteTypeDefinitions(entry, writer);
var obsoleteAttribute = entry.Member.GetCustomAttribute <ObsoleteAttribute>(false);
if (obsoleteAttribute != null)
{
await writer.WriteHeaderAsync(2, "Obsolete");
await writer.BeginParagraphAsync();
await writer.WriteLineAsync("This type should no longer be used and may be removed in the future. If you're using it, you should replace it as soon as possible. ");
await writer.WriteAsync(obsoleteAttribute.Message);
await file.WriteLineAsync();
}
if (entry.Documentation?.Example != null)
{
await writer.WriteHeaderAsync(4, "Example");
await WriteDocumentation(api, entry.Documentation?.Example, writer);
}
if (entry.Documentation?.Remarks != null)
{
await writer.WriteHeaderAsync(4, "Remarks");
await WriteDocumentation(api, entry.Documentation?.Remarks, writer);
}
await WriteMembers(api, entry, writer);
await writer.FlushAsync();
}
}
/// <summary>
/// Renders an element.
/// </summary>
/// <param name="element"> The parsed inline element to render. </param>
/// <param name="context"> Persistent state. </param>
protected virtual void RenderOtherRun(MarkdownInline element, IRenderContext context)
{
}
/// <summary>
/// 将行级元素转了 HTML
/// </summary>
/// <param name="block">MarkDown 行级元素</param>
/// <returns>HTML</returns>
public static string ToHtml(this MarkdownInline inline, string file)
{
var result = string.Empty;
switch (inline.Type)
{
case MarkdownInlineType.Comment: result += inline; break;
case MarkdownInlineType.Bold:
result += "<strong>";
(inline as BoldTextInline).Inlines.ToList().ForEach(p => result += p.ToHtml(file));
result += "</strong>";
break;
case MarkdownInlineType.Code: result += $" <code>{HtmlEncode((inline as CodeInline).Text)}</code> "; break;
case MarkdownInlineType.Image:
var image = inline as ImageInline;
var imageTooltip = string.IsNullOrEmpty(image.Tooltip) ? "" : $" alt='{image.Tooltip}'";
result += $"<img class='d-inline-block img-fluid' data-original='{image.Url.Split(' ')[0]}'{imageTooltip} referrerPolicy='no-referrer' />";
break;
case MarkdownInlineType.Italic:
result += "<em>";
(inline as ItalicTextInline).Inlines.ToList().ForEach(p => result += p.ToHtml(file));
result += "</em>";
break;
case MarkdownInlineType.MarkdownLink:
var markdownLink = inline as MarkdownLinkInline;
var markdownLinkUrl = markdownLink.Url ?? "javascript:";
var markdownLinkTooltip = string.IsNullOrEmpty(markdownLink.Tooltip) ? "" : $" title='{markdownLink.Tooltip}'";
if (markdownLinkUrl.IsExternalLink())
{
result += $" <a href='{markdownLinkUrl}' target='_blank'{markdownLinkTooltip}>";
}
else
{
result += $" <a href='{markdownLinkUrl.Replace(".md", ".html")}'{markdownLinkTooltip}>";
}
LinkCheck(file, markdownLinkUrl);
markdownLink.Inlines.ToList().ForEach(p => result += p.ToHtml(file));
result += "</a> ";
break;
case MarkdownInlineType.Strikethrough:
result += "<del>";
(inline as StrikethroughTextInline).Inlines.ToList().ForEach(p => result += p.ToHtml(file));
result += "</del>";
break;
case MarkdownInlineType.Subscript:
result += "<sub>";
(inline as SubscriptTextInline).Inlines.ToList().ForEach(p => result += p.ToHtml(file));
result += "</sub>";
break;
case MarkdownInlineType.Superscript:
result += "<sup>";
(inline as SuperscriptTextInline).Inlines.ToList().ForEach(p => result += p.ToHtml(file));
result += "</sup>";
break;
case MarkdownInlineType.TextRun:
var reg = new Regex("<(p|img|br|b|i|br|a|link|table|strong|tr|td|th|tbody|em|u|s|del|kbd)(\\W+|(\\s+.*?/?>))", RegexOptions.IgnoreCase);
var textRun = (inline as TextRunInline).ToString().Trim().Replace("|", "|");
if (reg.IsMatch(textRun))
{
result += textRun;
}
else
{
result += $"{HtmlEncode(textRun)}";
}
break;
case MarkdownInlineType.RawHyperlink:
var hyperLink = inline as HyperlinkInline;
var imgExName = new string[] { "jpg", "jpeg", "png", "gif" };
if (imgExName.ToList().Any(p => hyperLink.Text.Contains(p)))
{
result += hyperLink.Text;
}
else
{
if (hyperLink.Text.IsExternalLink())
{
result += $" <a href='{hyperLink.Text}' target='_blank'>{hyperLink.Text}</a> ";
}
else
{
result += $" <a href='{hyperLink.Text.Replace(".md", ".html")}'>{hyperLink.Text}</a> ";
LinkCheck(file, hyperLink.Text);
}
}
break;
case MarkdownInlineType.Emoji:
var emoji = inline as EmojiInline;
result += emoji.Text;
break;
case MarkdownInlineType.LinkReference:
result += (inline as LinkAnchorInline).Raw;
break;
case MarkdownInlineType.RawSubreddit:
//这是啥?
throw new NotImplementedException();
default: break;
}
return(result);
}
private string RenderInline(MarkdownInline inline) => _inlineRenderer.Render(inline, RenderInlines);
public string Render(MarkdownInline inline, RenderChildren renderChildren)
=> inline switch
{
