private void ParseMethod(List <IDocumentationMember> members, XmlNode node)
{
string name = node.Attributes["name"].Value.Substring(2);
Identifier member = Identifier.FromString(node.Attributes["name"].Value);
string methodName = GetMethodName(name);
int index = members.FindIndex(x => member.Equals(x.Name));
if (index == -1)
{
return; // TODO: Privates
}
if (methodName == "#ctor")
{
return; // TODO: Fix constructors
}
for (int i = 0; i < members.Count; i++)
{
var methodMember = members[i] as UndocumentedMethod;
if (methodMember != null && methodMember.Match(member))
{
members[i] = new DocumentedMethod(member, node, methodMember.Method, methodMember.TargetType);
}
}
}
private string GetUrl(DocumentedMethod method)
{
var nsRoute = _service.GetRoutePart(method.Type.Namespace);
var typeRoute = _service.GetRoutePart(method.Type);
var methodRoute = _service.GetRoutePart(method);
return(string.Concat(nsRoute, "/", typeRoute, "/", methodRoute));
}
public void Text_PlotMethods_AllHaveSummaries()
{
foreach (MethodInfo info in ScottPlot.Cookbook.Locate.GetPlotMethods())
{
var method = new DocumentedMethod(info, LoadedXmlDocument);
Assert.IsTrue(method.HasXmlDocumentation);
Assert.IsNotNull(method.Summary);
}
}
public static IHtmlString MethodLink(this ApiServices context, DocumentedMethod method, MethodRenderOption options)
{
if (method != null)
{
options = FixOptions(method, options);
var signature = context.SignatureResolver.GetMethodSignature(method);
return(context.SignatureRenderer.Render(signature, MethodRenderOption.Link | options));
}
return(MvcHtmlString.Empty);
}
public static IHtmlString BreadCrumb(this ApiServices context, DocumentedMethod method)
{
var breadcrumb = new Breadcrumb();
breadcrumb.AppendApiRoot();
breadcrumb.AppendNamespaces(context, method.Type.Namespace, true);
breadcrumb.AppendType(context, method.Type, true);
breadcrumb.AppendMethod(context, method);
return(breadcrumb.Render());
}
public void Add(List <Namespace> namespaces, DocumentedMethod association)
{
if (association.Method == null)
{
return;
}
var ns = FindNamespace(association, namespaces);
var type = FindType(ns, association);
try {
var methodReturnType = DeclaredType.Unresolved(
Identifier.FromType(association.Method.ReturnType),
association.Method.ReturnType,
Namespace.Unresolved(Identifier.FromNamespace(association.Method.ReturnType.Namespace)));
var doc = Method.Unresolved(
Identifier.FromMethod(association.Method, association.TargetType),
type, association.Method, methodReturnType);
ParseSummary(association, doc);
ParseRemarks(association, doc);
ParseValue(association, doc);
ParseReturns(association, doc);
ParseExample(association, doc);
foreach (var parameter in association.Method.GetParameters())
{
var reference = DeclaredType.Unresolved(
Identifier.FromType(parameter.ParameterType),
parameter.ParameterType,
Namespace.Unresolved(Identifier.FromNamespace(parameter.ParameterType.Namespace)));
var docParam = new MethodParameter(parameter.Name, reference);
ParseParamSummary(association, docParam);
doc.AddParameter(docParam);
}
if (matchedAssociations.ContainsKey(association.Name))
{
return; // weird case when a type has the same method declared twice
}
matchedAssociations.Add(association.Name, doc);
if (type == null)
{
return;
}
type.AddMethod(doc);
} catch (IOException ex) {
var doc = Method.Unresolved(
Identifier.FromMethod(association.Method, association.TargetType),
type, association.Method, new NullReference());
type.AddMethod(doc);
}
}
public IEncodedString DslType(DocumentedMethod method)
{
bool isPropertyAlias;
if (method.IsCakeAlias(out isPropertyAlias))
{
return(isPropertyAlias
? new HtmlEncodedString("Property")
: new HtmlEncodedString("Method"));
}
throw new InvalidOperationException("Unknown DSL alias type.");
}
public MethodSignature GetMethodSignature(DocumentedMethod method)
{
MethodSignature signature;
if (_documentedMethods.TryGetValue(method, out signature))
{
return(signature);
}
var message = $"Could not find signature for {method.Identity}.";
throw new InvalidOperationException(message);
}
public static IHtmlString MethodName(this ApiServices context, DocumentedMethod method)
{
if (method != null)
{
var options = MethodRenderOption.Name | MethodRenderOption.Parameters;
options = FixOptions(method, options);
var signature = context.SignatureResolver.GetMethodSignature(method);
return(context.SignatureRenderer.Render(signature, MethodRenderOption.Name | MethodRenderOption.Parameters));
}
return(MvcHtmlString.Empty);
}
protected string OneLineInfo(DocumentedMethod method, string baseUrl)
{
string url = Sanitize(method.Name);
StringBuilder sb = new StringBuilder();
sb.Append($"<a href='{baseUrl}#{url}'><strong>{method.Name}()</strong></a>");
if (!string.IsNullOrWhiteSpace(method.Summary))
{
sb.Append(" - " + method.Summary);
}
return(sb.ToString());
}
public IEncodedString DslLink(DocumentedMethod method)
{
var content = _context.SignatureRenderer.Render(
_context.Language,
method.Definition.GetMethodSignature(_context.UrlResolver),
MethodRenderOption.Name |
MethodRenderOption.Parameters |
MethodRenderOption.Link);
content = content.Replace("(ICakeContext, ", "(");
content = content.Replace("(ICakeContext)", string.Empty);
return(new RawString(content));
}
static void MatchMethod(List <IDocumentationMember> members, XmlNode node)
{
Identifier member = IdentifierFor.XmlString(node.Attributes["name"].Value);
for (int i = 0; i < members.Count; i++)
{
var reflected = members[i] as ReflectedMethod;
if (reflected != null && reflected.Match(member))
{
members[i] = new DocumentedMethod(reflected.Name, node, reflected.Method, reflected.TargetType);
}
}
}
private static MethodRenderOption FixOptions(DocumentedMethod method, MethodRenderOption options)
{
if (method.Metadata.IsAlias)
{
if (method.Metadata.IsPropertyAlias)
{
options |= MethodRenderOption.PropertyAlias;
}
else
{
options |= MethodRenderOption.MethodAlias;
}
}
return(options);
}
public void Text_Datagen_MethodsHaveSummaries()
{
foreach (MethodInfo info in typeof(ScottPlot.DataGen).GetMethods())
{
// skip abstract methods
if (info.DeclaringType.IsAbstract && info.DeclaringType != typeof(ScottPlot.DataGen)) // Static classes count as abstract since they cannot be instantiated.....
{
continue;
}
// skip inherited methods
if (info.DeclaringType.FullName is null || info.DeclaringType.FullName == "System.Object")
{
continue;
}
var m = new DocumentedMethod(info, LoadedXmlDocument);
Assert.IsNotNull(m.Summary, $"{m.FullName} has no summary.");
}
}
protected void AddDetailedInfo(DocumentedMethod p)
{
AddHeading(p.Name + "()", 3);
if (!string.IsNullOrWhiteSpace(p.Summary))
{
Add($"**Summary:** {p.Summary}");
}
Add($"**Name:** `{p.FullName}`");
Add($"**Signature:** `{p.Signature}`");
if (p.Parameters.Any())
{
StringBuilder sb = new StringBuilder();
sb.AppendLine($"**Parameters:**");
foreach (var p2 in p.Parameters)
{
string summary = string.IsNullOrWhiteSpace(p2.Summary) ? "" : "- " + p2.Summary;
sb.AppendLine($"* `{p2.Type}` **{p2.Name}** {summary}");
}
Add(sb.ToString());
}
}
public void Text_Plottables_MethodsHaveSummaries()
{
foreach (Type plottableType in ScottPlot.Cookbook.Locate.GetPlottableTypes())
{
foreach (MethodInfo info in ScottPlot.Cookbook.Locate.GetNotablePlottableMethods(plottableType))
{
// skip abstract methods
if (info.DeclaringType.IsAbstract)
{
continue;
}
// skip inherited methods
if (info.DeclaringType.FullName is null)
{
continue;
}
var m = new DocumentedMethod(info, LoadedXmlDocument);
Assert.IsNotNull(m.Summary);
}
}
}
public static IHtmlString MethodClassificationName(this ApiServices context, DocumentedMethod type)
{
if (type != null)
{
if (type.Metadata.IsAlias)
{
if (type.Metadata.IsPropertyAlias)
{
return(MvcHtmlString.Create("Cake Property Alias"));
}
return(MvcHtmlString.Create("Cake Method Alias"));
}
switch (type.MethodClassification)
{
case MethodClassification.Constructor:
return(MvcHtmlString.Create("Constructor"));
case MethodClassification.EventAccessor:
return(MvcHtmlString.Create("Event"));
case MethodClassification.ExtensionMethod:
return(MvcHtmlString.Create("Extension Method"));
case MethodClassification.Method:
return(MvcHtmlString.Create("Method"));
case MethodClassification.Operator:
return(MvcHtmlString.Create("Operator"));
default:
return(MvcHtmlString.Create("Unknown"));
}
}
return(MvcHtmlString.Create(string.Empty));
}
public MethodViewModel(ApiContext context, DocumentedMethod method, Content parent, string title)
: base(context, parent, title)
{
_method = method;
}
/// <summary>
/// Renders the syntax for a method.
/// </summary>
/// <param name="renderer">The syntax renderer to use.</param>
/// <param name="method">The method.</param>
/// <returns>The rendered syntax.</returns>
public static string Render(this ISyntaxRenderer renderer, DocumentedMethod method)
{
return(renderer.Render(method.Definition.GetMethodSignature(null)));
}
public static IHtmlString ExtensionMethodLink(this ApiServices context, DocumentedMethod method)
{
return(MethodLink(context, method, MethodRenderOption.Name | MethodRenderOption.Parameters | MethodRenderOption.ExtensionMethod));
}
public static IHtmlString Syntax(this ApiServices context, DocumentedMethod method)
{
return(context.SyntaxRenderer.Render(method.Definition.GetMethodSignature(null)));
}
public string GetRoutePart(DocumentedMethod method)
{
return($"{method.Identity.GetHashCode():X8}".ToLowerInvariant());
}
public MethodViewModel(DocumentedMethod data)
{
_data = data;
}
public static void AppendMethod(this IBreadcrumbItem breadcrumb, ApiServices context, DocumentedMethod method)
{
if (method.Definition.IsConstructor)
{
breadcrumb.Append(new BreadcrumbItem("Constructor"));
}
else
{
var methodSignature = context.SignatureResolver.GetMethodSignature(method);
breadcrumb.Append(new BreadcrumbItem(context.SignatureRenderer.Render(methodSignature, MethodRenderOption.Name), null));
}
}
public IEncodedString Syntax(DocumentedMethod method)
{
return(new RawString(_context.SyntaxRenderer.Render(method)));
}
public IEncodedString Link(DocumentedMethod method)
{
return(Link(method.Definition));
}
public string GetLinkPart(DocumentedMethod method)
{
return(string.Format("{0:X8}", method.Identity.GetHashCode()).ToLowerInvariant());
}