/// <summary>
/// Builds the markdown for the markdown page
/// </summary>
/// <param name="item">The markdown enum item</param>
/// <returns>The markdown text</returns>
public string BuildPage(MarkdownEnum item)
{
DefaultTheme.ThemeLogger?.LogDebug("Building Enum Page");
var mb = new MarkdownBuilder();
mb.HeaderWithCode(1, Cleaner.CreateFullTypeWithLinks(item, item.InternalType, false, false));
item.BuildNamespaceLinks(item.Namespace, mb);
if (_options.ShowAssembly)
{
mb.Append("Assembly: ").AppendLine(item.InternalType.Module.Name).AppendLine();
}
mb.AppendLine();
var comments = item.Comments;
if (!String.IsNullOrEmpty(item.Summary))
{
mb.AppendLine(item.Summary);
}
//mb.Append(GetCode(value));
mb.AppendLine();
BuildEnumTable(mb, comments, item);
return(mb.ToString());
}
/// <summary>
/// Builds the content for the markdown project page
/// </summary>
/// <param name="project">The markdown project item to be rendered</param>
/// <returns>The markdown content</returns>
public string BuildPage(MarkdownProject project)
{
DefaultTheme.ThemeLogger?.LogDebug("Building Main Api Page");
var homeBuilder = new MarkdownBuilder();
homeBuilder.HeaderWithLink(1, _options.RootTitle, project.To(project));
homeBuilder.AppendLine();
if (!string.IsNullOrEmpty(_options.RootSummary))
{
homeBuilder
.Header(2, "Summary")
.AppendLine(_options.RootSummary)
.AppendLine();
}
homeBuilder.Header(2, "Namespaces").AppendLine();
foreach (var tempItem in project.AllItems.Values.Where(i => i.ItemType == MarkdownItemTypes.Namespace))
{
var g = tempItem.As <MarkdownNamespace>();
if (!String.IsNullOrEmpty(g.FileName))
{
homeBuilder.HeaderWithLink(3, g.FullName, project.To(g));
}
else
{
homeBuilder.Header(3, g.Name);
}
homeBuilder.AppendLine();
if (!_options.ShowTypesOnRootPage)
{
continue;
}
foreach (var item in g.Types.OrderBy(x => x.Name))
{
if (!String.IsNullOrEmpty(item.FileName))
{
homeBuilder.List(Cleaner.CreateFullTypeWithLinks(project, item.InternalType, false, true));
}
else
{
homeBuilder.List(item.Name);
}
if (!string.IsNullOrEmpty(item.Summary))
{
homeBuilder.Tab().List(item.Summary);
}
}
}
homeBuilder.AppendLine();
return(homeBuilder.ToString());
}
/// <summary>
/// Builds the markdown content for the namespace page
/// </summary>
/// <param name="item">The markdown namespace item</param>
/// <returns>The markdown content</returns>
public string BuildPage(MarkdownNamespace item)
{
DefaultTheme.ThemeLogger?.LogDebug("Building Namespace Page");
var namespaceBuilder = new MarkdownBuilder();
namespaceBuilder.HeaderWithLink(1, item.FullName, item.To(item));
namespaceBuilder.AppendLine();
var summary = "";
if (!string.IsNullOrEmpty(item.Summary))
{
summary = item.Summary;
}
else if (_options.NamespaceSummaries.ContainsKey(item.FullName))
{
summary = _options.NamespaceSummaries[item.FullName];
}
if (!string.IsNullOrEmpty(summary))
{
namespaceBuilder.Header(2, "Summary");
namespaceBuilder.AppendLine(summary).AppendLine();
}
namespaceBuilder.Header(2, "Types").AppendLine();
foreach (var type in item.Types.OrderBy(x => x.Name))
{
var sb = new StringBuilder();
if (!String.IsNullOrEmpty(type.FileName))
{
namespaceBuilder.List(Cleaner.CreateFullTypeWithLinks(item, type.InternalType, false, true));
}
else
{
namespaceBuilder.List(item.Name);
}
if (!string.IsNullOrEmpty(type.Summary))
{
namespaceBuilder.Tab().List(type.Summary);
}
}
namespaceBuilder.AppendLine();
return(namespaceBuilder.ToString());
}
private void BuildTable(MarkdownBuilder mb, IMarkdownItem item, string[] headers, MarkdownMethod mdType)
{
mb.AppendLine();
List <string[]> data = new List <string[]>();
string[] dataValues = new string[headers.Length];
Type lookUpType = null;
if (item.ItemType == MarkdownItemTypes.Method)
{
lookUpType = item.As <MarkdownMethod>().ReturnType;
}
dataValues[0] = Cleaner.CreateFullTypeWithLinks(mdType, lookUpType, false, false);
string name = item.FullName;
if (item.ItemType == MarkdownItemTypes.Method)
{
name = Cleaner.CreateFullMethodWithLinks(mdType, item.As <MarkdownMethod>(), false, true, false);
}
else if (item.ItemType == MarkdownItemTypes.Property)
{
name = Cleaner.CreateFullParameterWithLinks(mdType, item.As <MarkdownProperty>(), false, _options.ShowParameterNames);
}
else if (item.ItemType == MarkdownItemTypes.Constructor)
{
name = Cleaner.CreateFullConstructorsWithLinks(mdType, item.As <MarkdownConstructor>(), false, _options.BuildConstructorPages);
}
dataValues[1] = name;
data.Add(dataValues);
mb.Table(headers, data, true);
mb.AppendLine();
}
/// <summary>
/// Builds the markdown method page content
/// </summary>
/// <param name="item">The markdown method item</param>
/// <returns>The markdown content</returns>
public string BuildPage(MarkdownMethod item)
{
Dictionary <string, string> parameterPairs = new Dictionary <string, string>();
Dictionary <string, string> returnPairs = new Dictionary <string, string>();
XmlDocumentComment[] comments = new XmlDocumentComment[0];
MarkdownBuilder mb = new MarkdownBuilder();
var name = Cleaner.CreateFullMethodWithLinks(item, item.As <MarkdownMethod>(), false, true, true);
// method name + params name with type
var FullName = item.Name + name;
var typeZeroHeaders = new[] { "Return", "Name" };
mb.HeaderWithLink(1, item.FullName, item.To(item));
mb.AppendLine();
mb.AppendLine(item.Summary);
BuildTable(mb, item, typeZeroHeaders, item);
mb.Append("#### Parameters");
mb.AppendLine();
if (File.Exists(MarkdownItemBuilder.xmlPath))
{
comments = VSDocParser.ParseXmlParameterComment(XDocument.Parse(File.ReadAllText(MarkdownItemBuilder.xmlPath)), "");
foreach (var comment in comments)
{
foreach (var param in item.Parameters)
{
var foundParameterComment = comment.Parameters.FirstOrDefault(x => x.Key == param.Name).Value;
if (foundParameterComment != null)
{
foundParameterComment = foundParameterComment.Substring(0, foundParameterComment.LastIndexOf('<'));
foundParameterComment = foundParameterComment.Substring(foundParameterComment.IndexOf('>') + 1);
var MethodName = Cleaner.CleanName(comment.MemberName, false, false);
// method name + param name + parameter summary
if (!parameterPairs.ContainsKey(MethodName + " " + param.Name))
{
parameterPairs.Add(MethodName + " " + param.Name, foundParameterComment);
}
}
}
}
}
var numberOfParameters = item.Parameters.Length;
for (int i = 1; i <= numberOfParameters; i++)
{
if (i == numberOfParameters)
{
ConstructParameter(mb, FullName, parameterPairs, false, i);
}
else
{
ConstructParameter(mb, FullName, parameterPairs, true, i);
}
}
mb.AppendLine();
mb.Append("#### Returns");
mb.AppendLine();
Type lookUpType = null;
if (item.ItemType == MarkdownItemTypes.Method)
{
lookUpType = item.As <MarkdownMethod>().ReturnType;
}
var returned = Cleaner.CreateFullTypeWithLinks(item, lookUpType, false, false);
string foundReturnComment = string.Empty;
if (File.Exists(MarkdownItemBuilder.xmlPath))
{
comments = VSDocParser.ParseXmlComment(XDocument.Parse(File.ReadAllText(MarkdownItemBuilder.xmlPath)), "");
if (comments != null)
{
foreach (var k in comments)
{
k.MemberName = Cleaner.CleanName(k.MemberName, false, false);
returnPairs[k.MemberName] = k.Returns;
}
foundReturnComment = returnPairs.FirstOrDefault(x => x.Key == item.Name).Value;
}
}
foundReturnComment = Regex.Replace(foundReturnComment, @"<see cref=""\w:([^\""]*)""\s*\/>", m => VSDocParser.ResolveSeeElement(m, ""));
Console.WriteLine(returned);
Console.WriteLine(foundReturnComment);
mb.Append(returned);
mb.AppendLine("<br>");
mb.Append(foundReturnComment);
return(mb.ToString());
}
/// <summary>
/// Builds the page of a MarkdownType and return the rendered markdown
/// </summary>
/// <param name="item">The markdown item to be rendered</param>
/// <returns>The markdown text</returns>
public string BuildPage(MarkdownType item)
{
DefaultTheme.ThemeLogger?.LogDebug("Building Type Page");
var mb = new MarkdownBuilder();
mb.HeaderWithCode(1, Cleaner.CreateFullTypeWithLinks(item, item.InternalType, false, false));
mb.AppendLine();
item.BuildNamespaceLinks(item.Namespace, mb);
if (_options.ShowAssembly)
{
mb.Append("Assembly: ").AppendLine(item.InternalType.Module.Name).AppendLine();
}
bool firstInterface = true;
foreach (var interfaceItem in item.InternalType.GetInterfaces())
{
if (firstInterface)
{
firstInterface = false;
mb.Append("Implements ");
}
else
{
mb.Append(", ");
}
var link = Cleaner.CreateFullTypeWithLinks(item, interfaceItem, false, false);
if (string.IsNullOrEmpty(link))
{
mb.Link(Cleaner.CleanName(interfaceItem.Name, false, false), "");
}
else
{
mb.Append(link);
}
}
if (!firstInterface)
{
mb.AppendLine().AppendLine();
}
if (!string.IsNullOrEmpty(item.Summary))
{
mb.Header(2, "Summary");
mb.AppendLine(item.Summary);
}
mb.AppendLine();
var typeZeroHeaders = new[] { "Name", "Summary" };
var typeOneHeaders = new[] { "Type", "Name", "Summary" };
var typeTwoHeaders = new[] { "Return", "Name", "Summary" };
BuildTable(mb, "Static Constructors", item.GetConstructors(true), typeZeroHeaders, item);
BuildTable(mb, "Constructors", item.GetConstructors(false), typeZeroHeaders, item);
BuildTable(mb, "Fields", item.GetFields(false), typeZeroHeaders, item);
BuildTable(mb, "Properties", item.GetProperties(false), typeZeroHeaders, item);
BuildTable(mb, "Methods", item.GetMethods(false), typeZeroHeaders, item);
BuildTable(mb, "Events", item.GetEvents(false), typeZeroHeaders, item);
BuildTable(mb, "Static Fields", item.GetFields(true), typeZeroHeaders, item);
BuildTable(mb, "Static Properties", item.GetProperties(true), typeZeroHeaders, item);
BuildTable(mb, "Static Methods", item.GetMethods(true), typeZeroHeaders, item);
BuildTable(mb, "Static Events", item.GetEvents(true), typeZeroHeaders, item);
return(mb.ToString());
}
private void BuildTable(MarkdownBuilder mb, string label, IMarkdownItem[] items, string[] headers, MarkdownType mdType)
{
if (items.Any())
{
mb.Header(2, label);
mb.AppendLine();
var seq = items.OrderBy(x => x.Name);
List <string[]> data = new List <string[]>();
foreach (var item in seq)
{
string[] dataValues = new string[headers.Length];
Type lookUpType = null;
if (item.ItemType == MarkdownItemTypes.Method)
{
lookUpType = item.As <MarkdownMethod>().ReturnType;
}
else if (item.ItemType == MarkdownItemTypes.Constructor)
{
lookUpType = null;
}
else
{
lookUpType = item.As <IMarkdownTypePartValue>().Type;
}
if (item.ItemType == MarkdownItemTypes.Constructor)
{
dataValues[0] = Cleaner.CreateFullConstructorsWithLinks(mdType, item.As <MarkdownConstructor>(), false, _options.ShowParameterNames);
}
else
{
dataValues[0] = Cleaner.CreateFullTypeWithLinks(mdType, lookUpType, false, false);
}
string name = item.FullName;
string summary = item.Summary;
if (item.ItemType == MarkdownItemTypes.Method)
{
name = Cleaner.CreateFullMethodWithLinks(mdType, item.As <MarkdownMethod>(), false, _options.ShowParameterNames, false);
}
else if (item.ItemType == MarkdownItemTypes.Property)
{
name = Cleaner.CreateFullParameterWithLinks(mdType, item.As <MarkdownProperty>(), false, _options.ShowParameterNames);
}
else if (item.ItemType == MarkdownItemTypes.Constructor)
{
name = Cleaner.CreateFullConstructorsWithLinks(mdType, item.As <MarkdownConstructor>(), false, _options.BuildConstructorPages);
}
dataValues[0] = name;
if (headers.Length > 1)
{
dataValues[1] = item.Summary;
}
data.Add(dataValues);
}
mb.Table(headers, data, true);
mb.AppendLine();
}
}
