/// <summary>
/// Renders the <see cref="ExceptionDoc"/> element to string containing the markup provided by <paramref name="markupProvider"/>
/// </summary>
/// <remarks>
/// Builds the link with the reference according to the <c>cref</c> attribute value. The value represents the Documentation ID
/// that can be matched to the information got during the code analysis or to build the link to MS API reference for the "MS objects".
/// First, it tries to resolve the <see cref="Member"/> in code being documented (internal link). If not successful, tries to look for
/// the <c>cref</c> (Documentation ID) in the MS API documentation if allowed/available (see <see cref="MsApiDocEngine"/> for details)
/// <para>
/// The link text is the the name of linked entity when using internal <see cref="IMarkupProvider.Link(string,net.adamec.dev.markupdoc.CodeModel.Member)"/>
/// or the <c>cref</c> without the leading type information when rendering .
/// When the link is not constructed ("target unknown"), the <c>cref</c> value without the leading type information is rendered in italic
/// </para>
/// <para>
/// The <exception> element is then rendered as <see cref="IMarkupProvider.DescriptionListItem"/> where
///<c>Term</c> is the link and <c>Description</c> is the fully trimmed element content.
/// Important: it returns description list item, so must be encapsulated on higher level !!!
/// </para>
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered content of <exception> element of XML Documentation Comments.
/// Important: it returns description list item, so must be encapsulated on higher level !!!</returns>
///<seealso cref="MsApiDocEngine"/>
/// <seealso cref="MsApiDocOptions"/>
protected override string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true)
{
//for exception always render both Ref(link if available) AND content
//content
var content = base.RenderElement(markupProvider, member, trim);
//ref
string exceptionRef;
if (member.Root.AllMembersByDocId.TryGetValue(Ref, out var refMember))
{
exceptionRef = markupProvider.Link(refMember.Name, refMember);
}
else
{
//Try to get the MS API link from reference
var msLink = MsApiDocEngine.GetLink(Ref);
//Got the MS link, so use external link
// ReSharper disable once ConvertIfStatementToConditionalTernaryExpression
if (msLink != null)
{
exceptionRef = markupProvider.ExternalLink(Ref.Substring(2), msLink);
}
else
{
//No link - Ref without leading "ref type"
exceptionRef = markupProvider.Italic(Ref.Substring(2));
}
}
//output
return(markupProvider.DescriptionListItem(exceptionRef, content));
}
/// <summary>
/// Зарегистрировать провайдер.
/// </summary>
/// <param name="markupProvider">Провайдер.</param>
public void RegisterProvider(IMarkupProvider markupProvider)
{
lock (providers)
{
providers[markupProvider.MarkupType] = markupProvider;
}
}
/// <summary>
/// Renders the element having the <c>cref</c> attribute to string containing the markup provided by <paramref name="markupProvider"/>
/// </summary>
/// <remarks>
/// Builds the link with the reference according to the <c>cref</c> attribute value. The value represents the Documentation ID
/// that can be matched to the information got during the code analysis or to build the link to MS API reference for the "MS objects".
/// First, it tries to resolve the <see cref="Member"/> in code being documented (internal link). If not successful, tries to look for
/// the <c>cref</c> (Documentation ID) in the MS API documentation if allowed/available (see <see cref="MsApiDocEngine"/> for details)
/// <para>
/// The link text is the rendered trimmed content of the tag if available,
/// the name of linked entity when using internal <see cref="IMarkupProvider.Link(string,net.adamec.dev.markupdoc.CodeModel.Member)"/>
/// or the <c>cref</c> without the leading type information when rendering <see cref="IMarkupProvider.ExternalLink"/>.
/// When the link is not constructed ("target unknown"), the <c>cref</c> value without the leading type information is rendered in italic
/// </para>
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered content of element of XML Documentation Comments</returns>
///<seealso cref="MsApiDocEngine"/>
/// <seealso cref="MsApiDocOptions"/>
protected override string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true) //used for links
{
// ReSharper disable once RedundantArgumentDefaultValue
var content = base.RenderElement(markupProvider, member, true); //always trim content for links
if (string.IsNullOrEmpty(Ref))
{
return(content);
}
//Return Ref to existing member as link, if available. If no content provided, use the member's name
if (member.Root.AllMembersByDocId.TryGetValue(Ref, out var refMember))
{
return(markupProvider.Link(!string.IsNullOrEmpty(content) ? content : refMember.Name, refMember));
}
//Try to get the MS API link from reference
var msLink = MsApiDocEngine.GetLink(Ref);
//Got the MS link, so return external link
if (msLink != null)
{
return(markupProvider.ExternalLink(!string.IsNullOrEmpty(content) ? content : Ref.Substring(2), msLink));
}
//No link, return content if available otherwise Ref without leading "ref type"
return(!string.IsNullOrEmpty(content) ? content : markupProvider.Italic(Ref.Substring(2)));
}
/// <summary>
/// Renders the <see cref="C"/> and its content to string
/// containing the markup provided by <paramref name="markupProvider"/>
/// </summary>
/// <remarks>
/// Gets (fully) trimmed content of the tag and renders it using <see cref="IMarkupProvider.InlineCode"/>
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered content of <c> element of XML Documentation Comments</returns>
protected override string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true)
{
// ReSharper disable once RedundantArgumentDefaultValue
var content = base.RenderElement(markupProvider, member, true); //always trim spaces for inline code.Text
content = markupProvider.InlineCode(content);
return(content);
}
/// <summary>
/// Writes to the footer for the code model member page
/// </summary>
/// <param name="baseFileName">Name of the main file</param>
/// <param name="markup">Markup provider</param>
/// <returns>String to be added to the footer</returns>
public string WritePageFooter(string baseFileName, IMarkupProvider markup)
{
if (SourceOnlyPackages != null && SourceOnlyPackages.Count > 0)
{
return(markup.Link("source-only packages", baseFileName, "package-list"));
}
return("");
}
/// <summary>
/// Renders the <see cref="ModelElement"/> and its content to string containing the markup provided by <paramref name="markupProvider"/>
/// </summary>
/// <remarks>
/// Gets content of the all child <see cref="Elements"/> and merges it together with a space as a separator.
/// If <paramref name="trim"/> parameter is set, the result is "fully" trimmed - the line breaks are replaced by spaces and leading/ending spaces are removed.
/// The parameter is also propagated to child's RenderElement function when getting the content.
/// Use <see cref="TagKeepLineBreak"/> and <see cref="TagKeepSpace"/> in derived classes to preserve the whitespaces.
/// when the parent element is to be rendered (and its content trimmed)
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered content of element/node of XML Documentation Comments</returns>
protected virtual string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true)
{
var sb = new StringBuilder();
foreach (var element in Elements)
{
sb.Append(element.RenderElement(markupProvider, member, trim) + " ");
}
return(trim ? sb.ToString().TrimAndMergeLines() : sb.ToString());
}
/// <summary>
/// Writes the header for the code model member
/// </summary>
/// <remarks>Writes source-only packages list if available</remarks>
/// <param name="member">Member being documented</param>
/// <param name="markup">Markup provider</param>
/// <returns>String to be added to the header text builder</returns>
public string WritePageHeader(Member member, IMarkupProvider markup)
{
SourceOnlyPackagesByMember.TryGetValue(member, out var packages);
if (packages == null || packages.Count < 1)
{
return(string.Empty);
}
return(markup.LineBreak() + "Source-only packages: " + string.Join(", ", packages.Select(p => Link(p.PackageId, p, markup))));
}
/// <summary>
/// Renders the <c>see</c> element - by default the <see cref="ModelElementWithCrefSimple.RenderElement"/> is used.
/// <c>langword</c> attribute is rendered when the base renders null or empty
/// </summary>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered content of element of XML Documentation Comments</returns>
protected override string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true) //used for links
{
// ReSharper disable once RedundantArgumentDefaultValue
var content = base.RenderElement(markupProvider, member, true); //always trim content for links
if (string.IsNullOrEmpty(content) && !string.IsNullOrEmpty(Langword))
{
return(markupProvider.InlineCode(Langword));
}
return(content ?? "");
}
/// <summary>
/// Renders the <see cref="Para"/> and its content to string containing the markup provided by <paramref name="markupProvider"/>
/// </summary>
/// <remarks>
/// Gets trimmed content of the tag and renders it using <see cref="IMarkupProvider.Para"/>.
/// Replaces the line breaks within the output with <see cref="ModelElement.TagKeepLineBreak"/> pseudo-tag
/// to preserve the line breaks in the markup when the parent element is to be rendered (and its content trimmed)
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered content of <para> element of XML Documentation Comments</returns>
protected override string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true)
{
// ReSharper disable once RedundantArgumentDefaultValue
var content = base.RenderElement(markupProvider, member, true); //always trim the content
content = markupProvider.Para(content);
content = content
.Replace("\r\n", TagKeepLineBreak)
.Replace("\r", TagKeepLineBreak)
.Replace("\n", TagKeepLineBreak);//preserve line breaks
return(content);
}
/// <summary>
/// Renders the <see cref="ModelElement"/> and its content to string containing the markup provided by <paramref name="markupProvider"/>.
/// This is the public "entry point" to <see cref="RenderElement"/> that does the final adjustment of the whitespaces.
/// </summary>
/// <remarks>
/// Gets content of the all child <see cref="Elements"/> and merges it together with a space as a separator.
/// The result is "fully" trimmed - the line breaks are replaced by spaces and leading/ending spaces are removed.
/// Use <see cref="TagKeepLineBreak"/> and <see cref="TagKeepSpace"/> in derived classes' <see cref="RenderElement"/> to preserve the whitespaces.
/// The <see cref="Render"/> method replaces <see cref="ModelElement.TagKeepLineBreak"/> and <see cref="ModelElement.TagKeepSpace"/>
/// pseudo-tags back to line breaks and spaces to preserve the "hard" whitespace required by the rendering method
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <returns>Rendered content of element/node of XML Documentation Comments</returns>
public virtual string Render(IMarkupProvider markupProvider, Member member)
{
var o = RenderElement(markupProvider, member);
o = o.TrimAndMergeLines(); //shrink whitespaces
//restore the "hard" whitespaces
o = o.Replace(TagKeepLineBreak, Environment.NewLine);
o = o.Replace(TagKeepSpace, " ");
o = o.Replace(TagKeepLineBreak.HtmlEncode(), Environment.NewLine); //also the html encoded values for code
o = o.Replace(TagKeepSpace.HtmlEncode(), " ");
return(o);
}
/// <summary>
/// Writes the body fro the code model member
/// </summary>
/// <remarks>This method is used as a sample only. It's not called as the <see cref="PriorityPageBody"/> is zero</remarks>
/// <param name="member">Member being documented</param>
/// <param name="markup">Markup provider</param>
/// <returns>Async task</returns>
public async Task WritePageBodyAsync(Member member, IMarkupProvider markup)
{
SourceOnlyPackagesByMember.TryGetValue(member, out var packages);
if (packages == null || packages.Count < 1)
{
return;
}
await markup.WriteH3Async("Source-only packages");
await markup.WriteParaAsync(new Txt()
.AddEach(p => $"{p.PackageId} - {p.PackageDescription}", packages, markup.LineBreak()));
}
/// <summary>
/// Renders the <see cref="Code"/> and its content to string containing the markup provided by <paramref name="markupProvider"/>
/// </summary>
/// <remarks>
/// Gets not-trimmed content of the tag and renders it using <see cref="IMarkupProvider.Code"/>.
/// Replaces the line breaks within the output with <see cref="ModelElement.TagKeepLineBreak"/> pseudo-tag and
/// spaces with <see cref="ModelElement.TagKeepSpace"/> pseudo-tag to preserve the whitespace when the
/// parent element is to be rendered (and its content trimmed)
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered content of <code> element of XML Documentation Comments</returns>
protected override string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true)
{
var content = base.RenderElement(markupProvider, member, false); //don't trim spaces for code.Text
content = content.Trim('\n').Trim('\r').TrimEnd().Trim('\n').Trim('\r'); //ensure "just code" without leading/ending line breaks and ending spaces
content = markupProvider.Code(content);
content = content
.Replace("\r\n", TagKeepLineBreak)
.Replace("\r", TagKeepLineBreak)
.Replace("\n", TagKeepLineBreak)
.Replace(" ", TagKeepSpace); //preserve whitespaces
return(content);
}
/// <summary>
/// Renders the <see cref="List"/> and its content to string containing the markup provided by <paramref name="markupProvider"/>
/// </summary>
/// <remarks>
/// Gets content of the all child <see cref="ListItem"/> elements and renders them into the list of required <see cref="ListType"/>.
///<list type="bullet">
/// <item>
/// <term>Bullet list</term>
/// <description>Each item contains "Term" in bold and "Description" (separated by dash). Both parts are optional.
/// This includes the list header item if present, however, there is no special handling for such item.</description>
/// </item>
/// <item>
/// <term>Numbered list</term>
/// <description>Each item contains "Term" in bold and "Description" (separated by dash). Both parts are optional.
/// This includes the list header item if present, however, there is no special handling for such item.</description></item>
/// <item>
/// <term>Table</term>
/// <description>Rendered as two column table (term and description). Both parts are optional.
/// Header item should be provided to define the table header ("Term" and "Description" are used as defaults)</description></item>
/// </list>
///The rendering uses <see cref="IMarkupProvider.List{T}"/> to render the lists and <see cref="IMarkupProvider.TableHeader"/>,
/// <see cref="IMarkupProvider.TableCols"/> and<see cref="IMarkupProvider.TableFooter"/> for table rendering.
/// Pseudo-tags <see cref="ModelElement.TagKeepLineBreak"/> and <see cref="ModelElement.TagKeepSpace"/> are used in the rendering output, to preserve the whitespaces
/// when the parent element is to be rendered (and its content trimmed)
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered list element of XML Documentation Comments</returns>
protected override string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true)
{
switch (ListType)
{
case ListTypeEnum.Bullet:
case ListTypeEnum.Number:
var content = markupProvider.List(li =>
{
{
var term = li.Term?.Render(markupProvider, member);
var description = li.Description?.Render(markupProvider, member) ?? "";
return(!string.IsNullOrEmpty(term)
? $"{markupProvider.Bold(term)}{(!string.IsNullOrEmpty(description) ? $" - {description}" : "")}"
: description);
}
}, Elements.OfType <ListItem>().ToList(), ListType == ListTypeEnum.Number);
content = $"{Environment.NewLine}{Environment.NewLine}{content}{Environment.NewLine}{Environment.NewLine}" //ensure proper separation from the text
.Replace("\r\n", TagKeepLineBreak)
.Replace("\r", TagKeepLineBreak)
.Replace("\n", TagKeepLineBreak)
.Replace(" ", TagKeepSpace); //preserve whitespaces
return(content);
case ListTypeEnum.Table:
var headerItem = Elements.OfType <ListItem>().FirstOrDefault(li => li.IsHeader);
var headerTerm = headerItem?.Term?.Render(markupProvider, member) ?? "Term";
var headerDescription = headerItem?.Description?.Render(markupProvider, member) ?? "Description";
var contentTbl = markupProvider.TableHeader(headerTerm, headerDescription);
foreach (var listItem in Elements.OfType <ListItem>().Where(li => !li.IsHeader))
{
var term = listItem.Term?.Render(markupProvider, member) ?? "";
var description = listItem.Description?.Render(markupProvider, member) ?? "";
contentTbl += markupProvider.TableCols(term, description);
}
contentTbl += markupProvider.TableFooter();
contentTbl = $"{Environment.NewLine}{Environment.NewLine}{contentTbl}{Environment.NewLine}{Environment.NewLine}" //ensure proper separation from the text
.Replace("\r\n", TagKeepLineBreak)
.Replace("\r", TagKeepLineBreak)
.Replace("\n", TagKeepLineBreak)
.Replace(" ", TagKeepSpace); //preserve whitespaces
return(contentTbl);
default:
return("");
}
}
/// <summary>
/// Creates the link to the <see cref="package"/> page
/// </summary>
/// <param name="text">Link text</param>
/// <param name="package">Package metadata</param>
/// <param name="markup">Markup provider</param>
/// <returns>Markup with the link to the <param name="package"></param></returns>
private string Link(string text, NuProps package, IMarkupProvider markup)
{
var fileName = string.Empty;
if (OutputOptions.SplitNs && !OutputOptions.SplitType)
{
fileName = GetPackagePagesFileName();
}
if (OutputOptions.SplitType)
{
fileName = GetPackagePageFileName(package);
}
var extension = markup.Extension;
return(markup.Link(text, string.IsNullOrEmpty(fileName) ? "" : $"{fileName}.{extension}", GetPackageAnchor(package)));
}
/// <summary>
/// Writes the table of all source-only packages within the code model into the output
/// </summary>
/// <param name="root">Code model root</param>
/// <param name="markup">Markup provider</param>
/// <returns>True when any output has been generated</returns>
public async Task <bool> WriteIndexAsync(RootMember root, IMarkupProvider markup)
{
if (SourceOnlyPackages == null || SourceOnlyPackages.Count < 1)
{
return(false);
}
await markup.WriteH2Async("Source-only packages", "package-list");
await markup.WriteTableHeaderAsync("Name", "Summary");
foreach (var nuProps in SourceOnlyPackages.OrderBy(p => p.PackageId))
{
await markup.WriteTableColsAsync(Link(nuProps.PackageId, nuProps, markup), nuProps.PackageDescription ?? string.Empty);
}
await markup.WriteTableFooterAsync();
return(true);
}
/// <summary>
/// Renders the <see cref="TypeParamRef"/> and its content to string containing the markup provided by <paramref name="markupProvider"/>
/// </summary>
/// <remarks>
/// When the element has the content (text), the content is rendered, otherwise the <c>name</c> attribute value in bold is rendered.
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered content of <typeparamref> element of XML Documentation Comments</returns>
protected override string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true)
{
var content = base.RenderElement(markupProvider, member, trim);
return(!string.IsNullOrEmpty(content) ? content : markupProvider.Bold(Name));
}
public ForumsCrawler(IMarkupProvider markupProvider)
{
this.markupProvider = markupProvider;
address = BaseForumsAddress + "page/";
}
/// <summary>
/// Writes the source-only packages pages into the output
/// </summary>
/// <param name="root">Code model root</param>
/// <param name="markup">Markup provider</param>
/// <param name="generator">Markup generator</param>
/// <returns>Async task</returns>
public async Task WriteOwnPagesAsync(RootMember root, IMarkupProvider markup, MarkupGenerator generator)
{
if (SourceOnlyPackages == null || SourceOnlyPackages.Count < 1)
{
return;
}
if (OutputOptions.SplitNs && !OutputOptions.SplitType)
{
//split by Ns only -> all source only packages will be on single page
await generator.SplitAsync(GetPackagePagesFileName());
}
foreach (var nuProps in SourceOnlyPackages.OrderBy(p => p.PackageId))
{
if (OutputOptions.SplitType)
{
//split by Type -> each source only packages will be on dedicated page
await generator.SplitAsync(GetPackagePageFileName(nuProps));
}
await markup.WriteH2Async($"{nuProps.PackageId} Source only package", GetPackageAnchor(nuProps));
await markup.WriteParaAsync(
markup.Small(
new Txt()
.AddIf($"Version: {nuProps.PackageVersion}", !string.IsNullOrEmpty(nuProps.PackageVersion))
.AddIf(markup.LineBreak(), !string.IsNullOrEmpty(nuProps.PackageVersion))
.AddIf($"Tags: {nuProps.PackageTags}", !string.IsNullOrEmpty(nuProps.PackageTags))
.AddIf(markup.LineBreak(), !string.IsNullOrEmpty(nuProps.PackageTags))
.Add($"Includes: {nuProps.IncludesType}")
.Add(markup.LineBreak())
.Add($"Declaring file: { PathUtils.GetRelativeSourceFile(nuProps.DeclaringFile,root.ProjectRootDir)}")
));
await markup.WriteParaAsync(nuProps.PackageDescription);
if (nuProps.Usings != null && nuProps.Usings.Count > 0)
{
await markup.WriteParaAsync(new Txt()
.Add(markup.Bold("Usings"))
.Add(markup.DescriptionList(
u =>
{
var refPkg = SourceOnlyPackages.FirstOrDefault(p => p.PackageId == u.PackageId);
return(refPkg == null ? u.PackageId : Link(u.PackageId, refPkg, markup));
},
u => string.IsNullOrEmpty(u.PackageVersion) ? string.Empty : $"version: {u.PackageVersion}",
nuProps.Usings)));
}
if (nuProps.ExternalReferences != null && nuProps.ExternalReferences.Count > 0)
{
await markup.WriteParaAsync(new Txt()
.Add(markup.Bold("References needed"))
.Add(markup.DescriptionList(
er => er,
er => string.Empty,
nuProps.ExternalReferences)));
}
if (nuProps.PackageRemarksSource != null &&
root.AllMembersByDocId.TryGetValue(nuProps.PackageRemarksSource, out var member))
{
var remarksDocumentation = member.Documentation?.GetRemarks(member)?.Render(markup, member);
if (!string.IsNullOrEmpty(remarksDocumentation))
{
await markup.WriteH3Async("Remarks");
await markup.WriteParaAsync(remarksDocumentation);
}
}
if (MembersBySourceOnlyPackage.TryGetValue(nuProps, out var members) && members.Count > 0)
{
await markup.WriteParaAsync(new Txt()
.Add(markup.Bold("Package members"))
.Add(markup.DescriptionList(
m => markup.Link($"{m.Name} ({m.MemberKind})", m),
m => m.Documentation?.GetSummary(m)?.Render(markup, m),
members)));
}
await markup.WriteParaAsync(new Txt()
.Add(markup.Bold("Sources"))
.Add(markup.DescriptionList(
f => $"{PathUtils.GetRelativeSourceFile(f,root.ProjectRootDir)}",
f => string.Empty,
nuProps.PackageFiles)));
await generator.WritePageFooterAsync();
}
}
/// <summary>
/// Конструктор.
/// </summary>
/// <param name="provider">Провайдер.</param>
/// <param name="tag">Тэг.</param>
public ApplyMarkupEventArgs(IMarkupProvider provider, MarkupTag tag)
{
this.provider = provider;
this.tag = tag;
}
/// <summary>
/// Renders the <see cref="Text"/> content to string
/// </summary>
/// <remarks>
/// The text content is by default fully trimmed meaning that the inner line breaks are replaced by spaces
/// and leading and ending spaces and line breaks are cut out.
/// </remarks>
/// <param name="markupProvider"><see cref="IMarkupProvider"/> allowing using the markup within the rendered content</param>
/// <param name="member">Code model <see cref="Member"/> to render the XML Documentation Comment for</param>
/// <param name="trim">Flag whether to (full) trim the rendered content</param>
/// <returns>Rendered text content of element in XML Documentation Comments</returns>
protected override string RenderElement(IMarkupProvider markupProvider, Member member, bool trim = true)
{
return(markupProvider.Text(trim ? Content.TrimAndMergeLines() : Content));
}
