public EventItem(AMemberItem parent, XElement element)
: base(parent, element)
{
TypeDefinition parentType = (parent as TypeItem).Type;
Event = parentType.Events.First(e => e.Name == Name);
}
public FieldItem(AMemberItem parent, XElement element)
: base(parent, element)
{
TypeDefinition parentType = (parent as TypeItem).Type;
Field = parentType.Fields.First(f => f.Name == Name);
}
public PropertyItem(AMemberItem parent, XElement element)
: base(parent, element)
{
XElement valueElement = element.GetValue();
Value = valueElement != null ? new ValueItem(this, valueElement) : null;
}
public MethodItem(AMemberItem parent, XElement item)
: base(parent, GetMethodName(item, parent), item)
{
XElement returnElement = item.GetReturns();
Return = returnElement != null ? new ReturnItem(this, returnElement) : null;
Parameters = item.GetParameters().Select(e => new ParameterItem(this, e)).ToArray();
}
private DocWriter(AMemberItem item, string filePath)
{
if (!_builders.TryDequeue(out _builder))
{
_builder = new StringBuilder(1024);
}
_item = item;
_filePath = filePath;
}
public ReturnItem(AMemberItem parent, XElement element)
: base(parent, element)
{
Type = parent switch
{
MethodItem methodItem => methodItem.Method.ReturnType,
OperatorItem operatorItem => operatorItem.Method.ReturnType,
_ => throw new NotSupportedException()
};
}
public PropertyItem(AMemberItem parent, XElement element)
: base(parent, GetPropertyName(element, parent), element)
{
TypeDefinition parentType = (parent as TypeItem).Type;
Property = parentType.Properties.First(p => p.Name == Name);
Parameters = element.GetParameters().Select(e => new ParameterItem(this, e)).ToArray();
Value = new ValueItem(this, element.GetValue() ?? new XElement("value"));
}
private static string GetNameWithoutGeneric(AMemberItem item)
{
if (item is TypeItem typeItem &&
typeItem.Generics.Length > 0)
{
return($"{item.Name.Substring(0, item.Name.IndexOf("<"))}`{typeItem.Generics.Length}");
}
return(item.Name);
}
public MethodItem(AMemberItem parent, XElement item)
: base(parent, GetMethodName(item, parent), item)
{
TypeDefinition parentType = (parent as TypeItem).Type;
string methodName = item.GetFullName().Substring(parent.Element.GetFullName().Length + 1).Replace('#', '.').Replace('@', '&');
Method = GetMethodDefinition(item, parent, parentType.Methods);
Return = new ReturnItem(this, item.GetReturns() ?? new XElement("returns"));
Parameters = item.GetParameters().Select(e => new ParameterItem(this, e)).ToArray();
}
public ParameterItem(AMemberItem parent, XElement element)
: base(parent, element)
{
Parameter = parent switch
{
MethodItem methodItem => methodItem.Method.Parameters.First(p => p.Name == Name),
OperatorItem operatorItem => operatorItem.Method.Parameters.First(p => p.Name == Name),
ConstructorItem constructorItem => constructorItem.Constructor.Parameters.First(p => p.Name == Name),
PropertyItem property => property.Property.Parameters.First(p => p.Name == Name),
_ => throw new NotSupportedException()
};
}
private static string GetPropertyName(XElement element, AMemberItem parent)
{
string name = element.GetName();
if (name.EndsWith(")"))
{
name = MethodItem.GetMethodName(element, parent);
name = $"this[{name.Substring(name.IndexOf('(') + 1).Replace(')', ']')}";
}
return(name);
}
private void WriteDocFor <T>(DocWriter writer, T item)
where T : AMemberItem
{
writer.WriteLine($"#### {MainName.AsLink()}");
AMemberItem parent = item.Parent;
Stack <AMemberItem> parents = new Stack <AMemberItem>();
while (parent != null)
{
parents.Push(parent);
parent = parent.Parent;
}
writer.WriteLine($"### {string.Join(".", parents.Select(i => i is NamespaceItem ? i.AsLinkWithTarget(MainName) : i.AsLink()))}");
item.Write(this, writer);
}
private void WriteLinkFor <T>(DocWriter writer, AMemberItem parent)
where T : AMemberItem
{
bool hasHeader = false;
foreach (T item in _items.Values.OfType <T>().Where(i => i.Parent == parent).OrderBy(i => i.Name))
{
if (!hasHeader)
{
hasHeader = true;
writer.WriteLine($"### {item.Header}");
}
writer.WriteLine($"- {item.AsLink()}");
}
}
private static MethodDefinition GetMethodDefinition(XElement element, AMemberItem parent, IEnumerable <MethodDefinition> methods)
{
string methodName = element.GetFullName().Substring(parent.Element.GetFullName().Length + 1)
.Replace('#', '.')
.Replace('@', '&')
.Replace('{', '<')
.Replace('}', '>');
int parametersIndex = methodName.IndexOf('(');
if (parametersIndex < 0)
{
parametersIndex = methodName.Length;
methodName += "()";
}
int genericsCount = 0;
int genericsIndex = methodName.IndexOf('`');
if (genericsIndex > 0 && genericsIndex < parametersIndex)
{
genericsCount = int.Parse(methodName.Substring(genericsIndex, parametersIndex - genericsIndex).Trim('`'));
methodName = methodName.Substring(0, genericsIndex) + methodName.Substring(parametersIndex);
}
string[] methodGenerics = GetGenericNames(element).ToArray();
for (int i = 0; i < methodGenerics.Length; ++i)
{
methodName = methodName.Replace($"``{i}", methodGenerics[i]);
}
GenericItem[] typeGenerics = (parent as TypeItem)?.Generics;
for (int i = 0; i < typeGenerics.Length; ++i)
{
methodName = methodName.Replace($"`{i}", typeGenerics[i].Name);
}
return(methods.First(m => m.GetName() == methodName && m.GenericParameters.Count == genericsCount));
}
public TypeItem(AMemberItem parent, XElement item, AssemblyDefinition assembly)
: base(parent, item)
{
string typeName = GetNameWithoutGeneric(this);
while (parent != null)
{
typeName = $"{GetNameWithoutGeneric(parent)}{(parent is TypeItem ? '/' : '.')}{typeName}";
parent = parent.Parent;
}
Type = assembly.MainModule.GetType(typeName);
if (Type.BaseType?.FullName == "System.MulticastDelegate")
{
Header = "Delegates";
Title = "delegate";
}
else if (Type.IsEnum)
{
Header = "Enums";
Title = "enum";
}
else if (Type.IsInterface)
{
Header = "Interfaces";
Title = "interface";
}
else if (Type.IsValueType)
{
Header = "Structs";
Title = "struct";
}
else
{
Header = "Classes";
Title = "class";
}
}
private void WriteDocFor <T>(DocWriter writer, T item)
where T : AMemberItem
{
writer.WriteLine($"#### {_mainName.AsLink()}");
AMemberItem parent = item.Parent;
Stack <AMemberItem> parents = new Stack <AMemberItem>();
while (parent != null)
{
parents.Push(parent);
parent = parent.Parent;
}
writer.WriteLine($"### {string.Join(".", parents.Select(i => i is NamespaceItem ? i.AsLinkWithTarget(_mainName) : i.AsLink()))}");
writer.WriteLine($"## {item.Name} `{item.Title}`");
WriteText(writer, item);
WriteItem(writer, item.Remarks);
WriteItem(writer, item.Example);
WriteItems(writer, (item as AGenericDocItem)?.Generics);
WriteItems(writer, (item as IParameterDocItem)?.Parameters);
WriteItem(writer, (item as IReturnDocItem)?.Return);
WriteItem(writer, (item as PropertyItem)?.Value);
WriteItems(writer, item.Exceptions);
}
public static GenericItem[] GetFrom(AMemberItem item)
{
return(item.Element.GetGenerics().Select(i => new GenericItem(item, i)).ToArray());
}
private GenericItem(AMemberItem parent, XElement element)
: base(parent, element)
{
}
public EventItem(AMemberItem parent, XElement element)
: base(parent, element)
{
}
public DocWriter(string path, AMemberItem item)
: this(item, Path.Combine(path, $"{item.LinkName}.md"))
{
}
public static ExceptionItem[] GetFrom(AMemberItem item)
{
return(item.Element.GetExceptions()?.Select(i => new ExceptionItem(item, i)).ToArray());
}
public bool IsForThis(AMemberItem item) => _item == item;
public ReturnItem(AMemberItem parent, XElement element)
: base(parent, element)
{
}
public ValueItem(AMemberItem parent, XElement element)
: base(parent, element)
{
Type = (parent as PropertyItem).Property.PropertyType;
}
private RemarksItem(AMemberItem parent, XElement element)
: base(parent, element)
{
}
public static RemarksItem GetFrom(AMemberItem item)
{
XElement remarksElement = item.Element.GetRemarks();
return(remarksElement != null ? new RemarksItem(item, remarksElement) : null);
}
private ExceptionItem(AMemberItem parent, XElement element)
: base(parent, element)
{
}
public TypeItem(AMemberItem parent, XElement item)
: base(parent, item)
{
}
public FieldItem(AMemberItem parent, XElement element)
: base(parent, element)
{
}
private void WriteText(DocWriter writer, AItem item)
{
string summary = string.Empty;
void WriteNodes(IEnumerable <XNode> nodes)
{
foreach (XNode node in nodes)
{
switch (node)
{
case XText text:
summary += string.Join(" \n", text.Value.Split('\n'));
break;
case XElement element:
switch (element.Name.LocalName)
{
case "see":
case "seealso":
string referenceName = element.GetReferenceName();
summary +=
_items.TryGetValue(referenceName, out AMemberItem reference)
? (reference is NamespaceItem ? reference.AsLinkWithTarget(_mainName) : reference.AsLink())
: referenceName.Substring(2).AsDotNetApiLink();
break;
case "typeparamref":
AMemberItem parent = item as AMemberItem ?? item.Parent;
GenericItem generic = null;
while (parent != null && generic == null)
{
if (parent is AGenericDocItem genericItem)
{
generic = Array.Find(genericItem.Generics, i => i.Name == element.GetName());
}
parent = parent.Parent;
}
if (generic == null)
{
summary += element.GetName();
}
else
{
summary +=
writer.IsForThis(generic.Parent)
? generic.AsPageLink()
: generic.AsLinkWithTarget();
}
break;
case "paramref":
IParameterDocItem parameterItem = (item as IParameterDocItem) ?? (item.Parent as IParameterDocItem);
ParameterItem parameter = parameterItem.Parameters.First(i => i.Name == element.GetName());
summary += parameter.AsPageLink();
break;
case "c":
summary += $"`{element.Value}`";
break;
case "code":
summary += $"```{element.Value}```\n";
break;
case "para":
summary += "\n\n";
WriteNodes(element.Nodes());
summary += "\n\n";
break;
default:
summary += element.ToString();
break;
}
break;
default:
throw new Exception($"unhandled node type in summary {node.NodeType}");
}
}
}
WriteNodes(item.Summary.Nodes());
string[] lines = summary.Split('\n');
int startIndex = 0;
int firstLine = 0;
foreach (string line in lines)
{
if (!string.IsNullOrWhiteSpace(line))
{
startIndex = line.Length - line.TrimStart().Length;
break;
}
++firstLine;
}
summary = string.Join(Environment.NewLine, lines.Skip(firstLine).Select(l => l.StartsWith(" ") ? l.Substring(startIndex) : l));
while (summary.EndsWith(Environment.NewLine))
{
summary = summary.Substring(0, summary.Length - Environment.NewLine.Length);
}
writer.WriteLine($"{summary.TrimEnd()}");
}
