/// <summary>
/// Parses the inheritance chain into text.
/// </summary>
/// <param name="inheritance">The inheritance chain.</param>
/// <returns>The parsed inheritance.</returns>
public static string ParseInheritance(
IList <TypeRef> inheritance)
{
var first = true;
var sb = new StringBuilder("Inheritance");
foreach (TypeRef i in inheritance)
{
if (first)
{
first = false;
}
else
{
sb.Append("→");
}
if (i == inheritance[^ 1])
{
sb.Append($" **{MarkdownWriter.Normalize(i.FriendlyName)}**");
continue;
}
sb.Append(Writer.WriteLink(i));
}
return(sb.ToString());
}
/// <summary>
/// Parses a <see cref="DocExportedType"/> to a <see cref="DocFile"/>.
/// </summary>
/// <param name="t">The <see cref="DocExportedType"/> to parse.</param>
/// <returns>The transformed <see cref="DocFile"/>.</returns>
private DocFile ProcessType(DocExportedType t)
{
var result = new DocFile(t.FileName);
var classification = t.IsInterface ? "Interface" : (t.IsEnum ? "Enum" : "Class");
result.AddThenBlankLine(writer.WriteHeading1($"{MarkdownWriter.Normalize(t.TypeRef.FriendlyName)} {classification}"));
result.AddThenBlankLine(ParserUtils.ProcessBreadcrumb(t));
result.AddThenBlankLine(t.Description);
ExtractCode(t.Code, result);
ExtractTypeParameters(t.TypeParameters, result);
if (t.Inheritance.Any())
{
result.AddThenBlankLine(ParserUtils.ParseInheritance(t.Inheritance));
}
if (t.ImplementedInterfaces.Any())
{
result.AddThenBlankLine(ParserUtils
.ParseImplementedInterfaces(t.ImplementedInterfaces));
}
if (t.DerivedTypes.Any())
{
result.AddThenBlankLine(ParserUtils
.ParseDerivedTypes(t.DerivedTypes));
}
ExtractExamples(t.Example, result);
ExtractRemarks(t.Remarks, result);
ExtractCtors(t.Constructor, result);
ExtractProperties(t.Properties, result);
ExtractMethods(t, result);
return(result);
}
/// <summary>
/// Extracts the constructors into a table and files.
/// </summary>
/// <param name="constructor">The <see cref="DocConstructor"/>.</param>
/// <param name="result">The <see cref="DocFile"/> to parse to.</param>
private void ExtractCtors(DocConstructor constructor, DocFile result)
{
if (constructor == null || !constructor.Overloads.Any())
{
return;
}
var ctorFile = new DocFile(constructor.FileName);
result.Files.Add(ctorFile);
result.AddThenBlankLine(writer.WriteHeading2($"Constructors"));
ctorFile.AddThenBlankLine(writer.WriteHeading1(
$"{MarkdownWriter.Normalize(constructor.ConstructorType.TypeRef.FriendlyName.NameOnly())} Constructors"));
ctorFile.AddThenBlankLine(ParserUtils.ProcessBreadcrumb(constructor));
ctorFile.AddThenBlankLine(constructor.Overloads[0].Description);
ctorFile.AddThenBlankLine(writer.WriteHeading2("Overloads"));
var table = new MarkdownTable("Ctor", "Description");
var tableCtor = new MarkdownTable("Ctor", "Description");
/// <summary>
/// Parses the XML comments.
/// </summary>
/// <param name="doc">The <see cref="XmlDocument"/> for XML comments.</param>
/// <param name="assembly">The <see cref="DocAssembly"/> to annotate.</param>
private void ParseXml(XmlDocument doc, DocAssembly assembly)
{
var typeList = assembly.Namespaces.SelectMany(ns => ns.Types);
foreach (var type in typeList)
{
var typeNode = doc.SelectSingleNode(type.XPath);
if (typeNode == null)
{
NotFound(type.XPath);
}
if (typeNode is XmlElement node)
{
type.Description = GetTextBlock(node, ParserUtils.Summary);
type.Remarks = GetTextBlock(node, ParserUtils.Remarks);
type.Example = GetTextBlock(node, ParserUtils.Example);
ProcessTypeParamDescriptions(node, type.TypeParameters);
}
if (type.Constructor != null && type.Constructor.Overloads.Any())
{
foreach (var overload in type.Constructor.Overloads)
{
var docNode = doc.SelectSingleNode(overload.XPath);
if (docNode == null)
{
NotFound(overload.XPath);
}
if (docNode is XmlElement ctorNode)
{
overload.Description = GetTextBlock(ctorNode, ParserUtils.Summary);
overload.Remarks = GetTextBlock(ctorNode, ParserUtils.Remarks);
overload.Example = GetTextBlock(ctorNode, ParserUtils.Example);
overload.Exceptions = GetExceptions(ctorNode);
ProcessParameters(overload.Parameters, ctorNode);
ProcessTypeParamDescriptions(ctorNode, overload.TypeParameters);
}
if (string.IsNullOrWhiteSpace(overload.Description))
{
var ctorType = overload.Constructor.ConstructorType.Type;
overload.Description =
$"Initializes a new instance of the [{MarkdownWriter.Normalize(TypeCache.Cache[ctorType].FriendlyName)}]({TypeCache.Cache[ctorType].Link}) class.";
}
}
}
if (type.Methods.Any())
{
foreach (var method in type.Methods)
{
foreach (var overload in method.MethodOverloads)
{
var oNode = doc.SelectSingleNode(overload.XPath);
if (oNode == null)
{
NotFound(overload.XPath);
}
if (oNode is XmlElement methodNode)
{
overload.Description = GetTextBlock(methodNode, ParserUtils.Summary);
overload.Remarks = GetTextBlock(methodNode, ParserUtils.Remarks);
overload.Example = GetTextBlock(methodNode, ParserUtils.Example);
overload.Exceptions = GetExceptions(methodNode);
overload.Returns = GetTextBlock(methodNode, ParserUtils.Returns);
ProcessParameters(overload.Parameters, methodNode);
ProcessTypeParamDescriptions(methodNode, overload.Method.MethodType.TypeParameters);
}
}
}
}
if (type.Properties.Any())
{
ProcessProperties(doc, type.Properties, type.TypeParameters);
}
}
}
