private static void Copy(MetadataItem dest, string srcName, ResolverContext context)
{
MetadataItem src = null;
// An explicit <inheritdoc/> (i.e. cref) overrides the default behavior
if (!string.IsNullOrEmpty(dest.InheritDoc) && context.Members.TryGetValue(dest.InheritDoc, out src))
{
srcName = dest.InheritDoc;
}
if (string.IsNullOrEmpty(srcName))
{
return;
}
if (src == null && !context.Members.TryGetValue(srcName, out src))
{
// Try to resolve any templated references before giving up
if (!context.References.TryGetValue(srcName, out var referenceItem) || referenceItem.Definition == null ||
!context.Members.TryGetValue(referenceItem.Definition, out src))
{
Logger.LogWarning($"Could not resolve base documentation for '{dest.Name}'",
file: dest.Source.Path,
line: dest.Source.StartLine != 0 ? dest.Source.StartLine.ToString() : null);
return;
}
}
Copy(dest, src, context);
}
private static void Copy(MetadataItem dest, string srcName, ResolverContext context)
{
MetadataItem src = null;
// An explicit <inheritdoc/> (i.e. cref) overrides the default behavior
if (!string.IsNullOrEmpty(dest.InheritDoc) && context.Members.TryGetValue(dest.InheritDoc, out src))
{
srcName = dest.InheritDoc;
}
if (string.IsNullOrEmpty(srcName))
{
return;
}
if (src == null && !context.Members.TryGetValue(srcName, out src))
{
// Try to resolve any templated references before giving up
if (!context.References.TryGetValue(srcName, out var referenceItem) || !context.Members.TryGetValue(referenceItem.Definition, out src))
{
return;
}
}
Copy(dest, src, context);
}
public static void ExecutePipeline(MetadataModel yaml, ResolverContext context)
{
foreach (var pipeline in pipelines)
{
pipeline.Run(yaml, context);
}
}
public static void ExecutePipeline(MetadataModel yaml, ResolverContext context)
{
foreach (var pipeline in pipelines)
{
pipeline.Run(yaml, context);
}
}
/// <summary>
/// TODO: input Namespace list instead;
/// TODO: Save to ...yml.map
/// </summary>
/// <param name="allMembers"></param>
/// <returns></returns>
public static MetadataModel ResolveMetadata(
Dictionary<string, MetadataItem> allMembers,
Dictionary<string, ReferenceItem> allReferences,
string apiFolder,
bool preserveRawInlineComments,
IEnumerable<string> externalReferencePackages)
{
MetadataModel viewModel = new MetadataModel();
viewModel.TocYamlViewModel = new MetadataItem()
{
Type = MemberType.Toc,
Items = allMembers.Where(s => s.Value.Type == MemberType.Namespace).Select(s => s.Value).ToList(),
};
viewModel.Members = new List<MetadataItem>();
ResolverContext context = new ResolverContext
{
ApiFolder = apiFolder,
References = allReferences,
PreserveRawInlineComments = preserveRawInlineComments,
};
ExecutePipeline(viewModel, context);
return viewModel;
}
/// <summary>
/// TODO: input Namespace list instead;
/// TODO: Save to ...yml.map
/// </summary>
/// <param name="allMembers"></param>
/// <returns></returns>
public static MetadataModel ResolveMetadata(
Dictionary <string, MetadataItem> allMembers,
Dictionary <string, ReferenceItem> allReferences,
string apiFolder,
bool preserveRawInlineComments,
IEnumerable <string> externalReferencePackages)
{
MetadataModel viewModel = new MetadataModel();
viewModel.TocYamlViewModel = new MetadataItem()
{
Type = MemberType.Toc,
Items = allMembers.Where(s => s.Value.Type == MemberType.Namespace).Select(s => s.Value).ToList(),
};
viewModel.Members = new List <MetadataItem>();
ResolverContext context = new ResolverContext
{
ApiFolder = apiFolder,
References = allReferences,
PreserveRawInlineComments = preserveRawInlineComments,
};
ExecutePipeline(viewModel, context);
return(viewModel);
}
public void Run(MetadataModel yaml, ResolverContext context)
{
if (yaml.Members != null && yaml.Members.Count > 0)
{
UpdateDerivedClassMapping(yaml.Members, context.References);
AppendDerivedClass(yaml.Members);
}
}
public void Run(MetadataModel yaml, ResolverContext context)
{
if (yaml.Members != null && yaml.Members.Count > 0)
{
UpdateDerivedClassMapping(yaml.Members, context.References);
AppendDerivedClass(yaml.Members);
}
}
static void Copy(MetadataItem dest, MetadataItem src, ResolverContext context)
{
if (src.IsInheritDoc)
{
InheritDoc(src, context);
}
dest.CopyInheritedData(src);
}
private static void Copy(MetadataItem dest, string srcName, ResolverContext context)
{
if (string.IsNullOrEmpty(srcName) || !context.Members.TryGetValue(srcName, out MetadataItem src))
{
return;
}
Copy(dest, src, context);
}
public void Run(MetadataModel yaml, ResolverContext context)
{
TreeIterator.Preorder(yaml.TocYamlViewModel, null,
s => s.IsInvalid ? null : s.Items,
(current, parent) =>
{
current.Parent = parent;
return(true);
});
}
public void Run(MetadataModel yaml, ResolverContext context)
{
TreeIterator.Preorder(yaml.TocYamlViewModel, null,
s => s.IsInvalid ? null : s.Items,
(current, parent) =>
{
current.Parent = parent;
return true;
});
}
private static void Copy(MetadataItem dest, MetadataItem src, ResolverContext context)
{
if (src.InheritDoc != null)
{
InheritDoc(src, context);
src.InheritDoc = null;
}
dest.CopyInheritedData(src);
dest.InheritDoc = null;
}
private void AddIndirectReference(ResolverContext context, MetadataItem page, List <ReferenceItem> addedReferences)
{
while (addedReferences.Count > 0)
{
var addingReferences = new List <ReferenceItem>();
foreach (var r in addedReferences)
{
foreach (var key in GetReferenceKeys(r))
{
TryAddReference(context, page, addingReferences, key);
}
}
addedReferences = addingReferences;
}
}
private void AddIndirectReference(ResolverContext context, MetadataItem page, List<ReferenceItem> addedReferences)
{
while (addedReferences.Count > 0)
{
var addingReferences = new List<ReferenceItem>();
foreach (var r in addedReferences)
{
foreach (var key in GetReferenceKeys(r))
{
TryAddReference(context, page, addingReferences, key);
}
}
addedReferences = addingReferences;
}
}
public void Run(MetadataModel yaml, ResolverContext context)
{
TreeIterator.Preorder(
yaml.TocYamlViewModel,
null,
s => s.IsInvalid ? null : s.Items,
(current, parent) =>
{
if (current.InheritDoc != null)
{
InheritDoc(current, context);
current.InheritDoc = null;
}
return(true);
});
}
private static void TryAddReference(ResolverContext context, MetadataItem page, List <ReferenceItem> addingReferences, string key)
{
if (!page.References.ContainsKey(key))
{
if (context.References.TryGetValue(key, out ReferenceItem item))
{
var reference = context.References[key].Clone();
page.References.Add(key, reference);
addingReferences.Add(reference);
}
else
{
Debug.Fail($"Reference not found: {key}");
}
}
}
/// <summary>
/// The yaml layout should be
/// namespace -- class level -- method level
/// </summary>
/// <param name="allMembers"></param>
/// <returns></returns>
public void Run(MetadataModel yaml, ResolverContext context)
{
StringBuilder message = new StringBuilder();
foreach (var member in yaml.TocYamlViewModel.Items)
{
var result = CheckNamespaces(member);
if (!string.IsNullOrEmpty(result))
{
message.AppendLine(result);
}
}
if (message.Length > 0)
{
Logger.LogWarning(message.ToString());
}
}
private static void TryAddReference(ResolverContext context, MetadataItem page, List<ReferenceItem> addingReferences, string key)
{
if (!page.References.ContainsKey(key))
{
ReferenceItem item;
if (context.References.TryGetValue(key, out item))
{
var reference = context.References[key].Clone();
page.References.Add(key, reference);
addingReferences.Add(reference);
}
else
{
Debug.Fail(string.Format("Reference not found: {0}", key));
}
}
}
/// <summary>
/// The yaml layout should be
/// namespace -- class level -- method level
/// </summary>
/// <param name="allMembers"></param>
/// <returns></returns>
public void Run(MetadataModel yaml, ResolverContext context)
{
StringBuilder message = new StringBuilder();
foreach (var member in yaml.TocYamlViewModel.Items)
{
var result = CheckNamespaces(member);
if (!string.IsNullOrEmpty(result))
{
message.AppendLine(result);
}
}
if (message.Length > 0)
{
Logger.LogWarning(message.ToString());
}
}
public void Run(MetadataModel yaml, ResolverContext context)
{
TreeIterator.Preorder(yaml.TocYamlViewModel, null,
s =>
{
if (s.IsInvalid || (s.Type != MemberType.Namespace && s.Type != MemberType.Toc)) return null;
else return s.Items;
},
(member, parent) =>
{
if (member.Type != MemberType.Toc)
{
yaml.Members.Add(member);
}
return true;
});
}
public void Run(MetadataModel yaml, ResolverContext context)
{
TreeIterator.Preorder(yaml.TocYamlViewModel, null,
s => s.IsInvalid ? null : s.Items,
(current, parent) =>
{
MetadataItem page;
var addingReferences = new List<ReferenceItem>();
var documentReferences = current.References;
if (current.Type.IsPageLevel())
{
page = current;
current.References = new Dictionary<string, ReferenceItem>();
}
else
{
page = parent;
current.References = null;
}
if (documentReferences != null && documentReferences.Count > 0)
{
foreach (var key in documentReferences.Keys)
{
TryAddReference(context, page, addingReferences, key);
}
}
foreach (var key in GetReferenceKeys(current))
{
TryAddReference(context, page, addingReferences, key);
}
if (current.Type == MemberType.Namespace)
{
foreach (var item in current.Items)
{
TryAddReference(context, page, addingReferences, item.Name);
}
}
AddIndirectReference(context, page, addingReferences);
return true;
});
}
public void Run(MetadataModel yaml, ResolverContext context)
{
TreeIterator.Preorder(yaml.TocYamlViewModel, null,
s => s.IsInvalid ? null : s.Items,
(current, parent) =>
{
MetadataItem page;
var addingReferences = new List <ReferenceItem>();
var documentReferences = current.References;
if (current.Type.IsPageLevel())
{
page = current;
current.References = new Dictionary <string, ReferenceItem>();
}
else
{
page = parent;
current.References = null;
}
if (documentReferences != null && documentReferences.Count > 0)
{
foreach (var key in documentReferences.Keys)
{
TryAddReference(context, page, addingReferences, key);
}
}
foreach (var key in GetReferenceKeys(current))
{
TryAddReference(context, page, addingReferences, key);
}
if (current.Type == MemberType.Namespace)
{
foreach (var item in current.Items)
{
TryAddReference(context, page, addingReferences, item.Name);
}
}
AddIndirectReference(context, page, addingReferences);
return(true);
});
}
public void Run(MetadataModel yaml, ResolverContext context)
{
TreeIterator.Preorder(
yaml.TocYamlViewModel,
null,
s => s.IsInvalid ? null : s.Items,
(member, parent) =>
{
// get all the possible places where link is possible
if (member.Syntax != null && member.Syntax.Content != null)
{
SyntaxLanguage[] keys = new SyntaxLanguage[member.Syntax.Content.Count];
member.Syntax.Content.Keys.CopyTo(keys, 0);
foreach (var key in keys)
{
member.Syntax.Content[key] = NormalizeLines(member.Syntax.Content[key]);
}
}
return(true);
});
}
public void Run(MetadataModel yaml, ResolverContext context)
{
TreeIterator.Preorder(
yaml.TocYamlViewModel,
null,
s => s.IsInvalid ? null : s.Items,
(member, parent) =>
{
// get all the possible places where link is possible
if (member.Syntax != null && member.Syntax.Content != null)
{
SyntaxLanguage[] keys = new SyntaxLanguage[member.Syntax.Content.Count];
member.Syntax.Content.Keys.CopyTo(keys, 0);
foreach(var key in keys)
{
member.Syntax.Content[key] = NormalizeLines(member.Syntax.Content[key]);
}
}
return true;
});
}
public void Run(MetadataModel yaml, ResolverContext context)
{
TreeIterator.Preorder(yaml.TocYamlViewModel, null,
s =>
{
if (s.IsInvalid || (s.Type != MemberType.Namespace && s.Type != MemberType.Toc))
{
return(null);
}
else
{
return(s.Items);
}
},
(member, parent) =>
{
if (member.Type != MemberType.Toc)
{
yaml.Members.Add(member);
}
return(true);
});
}
static void InheritDoc(MetadataItem dest, ResolverContext context)
{
dest.IsInheritDoc = false;
switch (dest.Type)
{
case MemberType.Constructor:
if (dest.Parent == null || dest.Syntax == null || dest.Syntax.Parameters == null)
{
return;
}
Debug.Assert(dest.Parent.Type == MemberType.Class);
//try to find the base class
if (dest.Parent.Inheritance?.Count == 0)
{
return;
}
MetadataItem baseClass;
if (!context.Members.TryGetValue(dest.Parent.Inheritance[dest.Parent.Inheritance.Count - 1], out baseClass))
{
return;
}
if (baseClass.Items == null)
{
return;
}
//look a constructor in the base class which has a matching signature
foreach (var ctor in baseClass.Items)
{
if (ctor.Type != MemberType.Constructor)
{
continue;
}
if (ctor.Syntax == null || ctor.Syntax.Parameters == null)
{
continue;
}
if (ctor.Syntax.Parameters.Count != dest.Syntax.Parameters.Count)
{
continue;
}
bool parametersMatch = true;
for (int ndx = 0; ndx < dest.Syntax.Parameters.Count; ndx++)
{
var myParam = dest.Syntax.Parameters[ndx];
var baseParam = ctor.Syntax.Parameters[ndx];
if (myParam.Name != baseParam.Name)
{
parametersMatch = false;
}
if (myParam.Type != baseParam.Type)
{
parametersMatch = false;
}
}
if (parametersMatch)
{
Copy(dest, ctor, context);
return;
}
}
break;
case MemberType.Method:
case MemberType.Property:
case MemberType.Event:
Copy(dest, dest.Overridden, context);
if (dest.Implements != null)
{
foreach (var item in dest.Implements)
{
Copy(dest, item, context);
}
}
break;
case MemberType.Class:
if (dest.Inheritance.Count != 0)
{
Copy(dest, dest.Inheritance[dest.Inheritance.Count - 1], context);
}
if (dest.Implements != null)
{
foreach (var item in dest.Implements)
{
Copy(dest, item, context);
}
}
break;
}
}
