private static void EmptyToNull(ArticleItemYaml yaml)
{
if (yaml.Children != null && yaml.Children.Count == 0)
{
yaml.Children = null;
}
if (yaml.Inheritance != null && yaml.Inheritance.Count == 0)
{
yaml.Inheritance = null;
}
if (yaml.InheritedMembers != null && yaml.InheritedMembers.Count == 0)
{
yaml.InheritedMembers = null;
}
if (yaml.Sees != null && yaml.Sees.Count == 0)
{
yaml.Sees = null;
}
if (yaml.Syntax != null && yaml.Syntax.Parameters != null && yaml.Syntax.Parameters.Count == 0)
{
yaml.Syntax.Parameters = null;
}
if (yaml.Syntax != null && yaml.Syntax.TypeParameters != null && yaml.Syntax.TypeParameters.Count == 0)
{
yaml.Syntax.TypeParameters = null;
}
if (yaml.Exceptions != null && yaml.Exceptions.Count == 0)
{
yaml.Exceptions = null;
}
}
private MemberSDPModel AutoMapArticleItemYamlToMemberSDPModel(ArticleItemYaml articleItemYaml)
{
if (articleItemYaml == null)
{
return(null);
}
var memberSDPModel = new MemberSDPModel();
memberSDPModel.FullName = articleItemYaml.FullName.RemoveFromValue("(");
memberSDPModel.Name = articleItemYaml.Name;
memberSDPModel.NameWithType = articleItemYaml.NameWithType.RemoveFromValue("(");
memberSDPModel.Uid = articleItemYaml.Uid;
memberSDPModel.Type = articleItemYaml.Type.ToString().ToLower();
memberSDPModel.Package = articleItemYaml.PackageName;
memberSDPModel.Members = new List <Member>();
var member = TransferMember(articleItemYaml);
if (member != null)
{
memberSDPModel.Members.Add(member);
}
return(memberSDPModel);
}
protected override IEnumerable <string> GetDefaultInheritance(ArticleItemYaml yaml)
{
if (yaml.Type == MemberType.Class)
{
yield return("System::Object");
}
}
protected override void FillLanguageSpecificMetadata(ArticleItemYaml yaml, ArticleContext context, XElement node)
{
HierarchyChange curChange = context.CurrentChange;
HierarchyChange parentChange = context.ParentChange;
yaml.PackageName = parentChange?.Uid;
}
protected void FillSource(ArticleItemYaml yaml, XElement node)
{
var location = node.NullableElement("location");
if (!location.IsNull())
{
string headerPath = location.NullableAttribute("file").NullableValue();
string headerStartlineStr = location.NullableAttribute("line").NullableValue();
int headerStartline = ParseStartline(headerStartlineStr);
string bodyPath = location.NullableAttribute("bodyfile").NullableValue();
string bodyStartlineStr = location.NullableAttribute("bodystart").NullableValue();
int bodyStartline = ParseStartline(bodyStartlineStr);
string path = bodyPath ?? headerPath;
int startLine = path == bodyPath ? bodyStartline : headerStartline;
var info = GitUtility.GetGitInfo(path);
string relativePath = GetRelativePath(path, info?.LocalWorkingDirectory);
yaml.Source = new SourceDetail
{
Remote = new GitDetail {
RemoteRepositoryUrl = info?.RemoteRepoUrl, RemoteBranch = info?.RemoteBranch, RelativePath = relativePath
},
Path = relativePath,
StartLine = startLine,
};
}
}
protected void FillSummary(ArticleItemYaml yaml, XElement node)
{
yaml.Summary = node.NullableElement("briefdescription").NullableInnerXml() + ParseSummaryFromDetailedDescription(node.NullableElement("detaileddescription"));
if (yaml.Summary == string.Empty)
{
yaml.Summary = null;
}
}
protected void FillSyntax(ArticleItemYaml yaml, XElement node, bool isMain)
{
yaml.Syntax = new SyntaxDetailViewModel();
FillTypeParameters(yaml.Syntax, node);
FillParameters(yaml.Syntax, node);
FillReturn(yaml.Syntax, node);
FillDeclaration(yaml.Syntax, node, isMain);
}
protected void FillInheritedMembers(ArticleItemYaml yaml, XElement node)
{
var allMembers = from m in node.NullableElement("listofallmembers").Elements("member")
where !YamlUtility.IsFiltered(m.NullableAttribute("prot").NullableValue())
select m.NullableAttribute("refid").NullableValue();
yaml.InheritedMembers = allMembers.Except(yaml.Children).ToList();
_references.AddRange(yaml.InheritedMembers.Select(i => new ReferenceViewModel {
Uid = i
}));
}
protected void FillSees(ArticleItemYaml yaml, XElement node)
{
var sees = node.XPathSelectElements("detaileddescription/para/simplesect[@kind='see']/para/ref");
yaml.Sees = (from see in sees
select new CrefInfo
{
Type = see.NullableAttribute("refid").NullableValue(),
Description = see.NullableInnerXml()
}).ToList();
}
protected override IEnumerable <string> GetDefaultInheritance(ArticleItemYaml yaml)
{
if (yaml.Type == MemberType.Enum)
{
yield return($"java.lang.Enum<{yaml.Name}>");
}
if (yaml.Type == MemberType.Class || yaml.Type == MemberType.Enum)
{
yield return("java.lang.Object");
}
}
protected void FillOverload(ArticleItemYaml yaml, XElement node)
{
var kind = node.NullableAttribute("kind").NullableValue();
var type = KindMapToType(kind).Item1;
switch (type)
{
case MemberType.Method:
case MemberType.Constructor:
yaml.Overload = AddOverloadReference(yaml);
break;
}
}
protected void FillRemarks(ArticleItemYaml yaml, XElement node)
{
var par = node.XPathSelectElement("detaileddescription/para/simplesect[@kind='par']");
if (par?.NullableInnerXmlRemoveBr()?.StartsWith("<title>API Note:</title>") != true)
{
return;
}
yaml.Remarks = WebUtility.HtmlDecode(node.XPathSelectElement("detaileddescription/para/simplesect[@kind='par']/para").NullableInnerXmlRemoveBr());
if (yaml.Remarks == string.Empty)
{
yaml.Remarks = null;
}
}
protected void FillImplementsOrInherits(ArticleItemYaml yaml, XElement node)
{
foreach (var basenode in node.Elements("basecompoundref"))
{
string refId = basenode.NullableAttribute("refid").NullableValue();
string specializedFullName = YamlUtility.RegularizeName(basenode.NullableValue(), Constants.Dot);
if (refId != null)
{
yaml.ImplementsOrInherits.Add(new SpecializedType {
Type = refId, SpecializedFullName = specializedFullName
});
}
}
}
protected void FillException(ArticleItemYaml yaml, XElement node)
{
yaml.Exceptions = new List <CrefInfo>();
var exceptions = node.XPathSelectElements("detaileddescription/para/parameterlist[@kind='exception']/parameteritem");
foreach (var ex in exceptions)
{
yaml.Exceptions.Add(
new CrefInfo()
{
Type = ParseType(ex.XPathSelectElement("parameternamelist/parametername")),
Description = ex.NullableElement("parameterdescription").NullableInnerXml(),
});
}
}
protected void FillInheritance(NameGeneratorContext context, ArticleItemYaml yaml, XElement node)
{
if (yaml.Type == MemberType.Interface)
{
return;
}
var nodeIdHash = new Dictionary <string, string>();
var idHash = new Dictionary <string, List <string> >();
var inheritanceGraph = node.NullableElement("inheritancegraph");
foreach (var n in inheritanceGraph.Elements("node"))
{
string nodeId = n.NullableAttribute("id").NullableValue();
string id = n.NullableElement("link").NullableAttribute("refid").NullableValue() ?? _nameGenerator.GenerateLabel(context, n);
nodeIdHash.Add(nodeId, id);
var childNode = n.NullableElement("childnode");
if (!childNode.IsNull())
{
if (!idHash.ContainsKey(nodeId))
{
idHash[nodeId] = new List <string>();
}
idHash[nodeId].Add(childNode.NullableAttribute("refid").NullableValue());
}
}
//yaml.Inheritance = idHash.ToDictionary(pair => nodeIdHash[pair.Key], pair => pair.Value.Select(n => nodeIdHash[n]).ToList());
// var dict = idHash.ToDictionary(pair => nodeIdHash[pair.Key], pair => pair.Value.Select(n => nodeIdHash[n]).ToList());
var dict = idHash.GroupBy(pair => Regex.Replace(nodeIdHash[pair.Key], "<.*?>", string.Empty)).ToDictionary(g => g.Key, g => g.SelectMany(p => p.Value).Select(n => nodeIdHash[n]).ToList());
yaml.Inheritance = new List <string>();
string start = yaml.Uid;
while (dict.ContainsKey(start))
{
start = dict[start].Single();
yaml.Inheritance.Add(start);
}
var defaultInheritance = GetDefaultInheritance(yaml);
yaml.Inheritance.AddRange(defaultInheritance);
yaml.Inheritance.Reverse();
}
private string AddOverloadReference(ArticleItemYaml yaml)
{
string id = yaml.Uid;
var uidBody = RemoveArgs(id);
uidBody = GenericMethodPostFix.Replace(uidBody, string.Empty);
string uid = uidBody + "*";
ReferenceViewModel reference = new ReferenceViewModel()
{
Uid = uid,
Name = RemoveArgs(yaml.Name),
FullName = RemoveArgs(yaml.FullName),
NameWithType = RemoveArgs(yaml.NameWithType),
PackageName = yaml.PackageName,
};
_references.Add(reference);
return(uid);
}
protected Member TransferMember(ArticleItemYaml articleItemYaml)
{
if (articleItemYaml == null)
{
return(null);
}
var member = new Member();
member.FullName = articleItemYaml.FullName;
member.Name = articleItemYaml.Name;
member.NameWithType = articleItemYaml.NameWithType;
member.Overridden = articleItemYaml.Overridden;
member.Parameters = TransferParameters(articleItemYaml.Syntax);
member.Exceptions = TransferExceptions(articleItemYaml.Exceptions);
member.Returns = TransferReturns(articleItemYaml.Syntax);
member.Syntax = TransferSyntax(articleItemYaml.Syntax);
member.Summary = articleItemYaml.Summary;
member.TypeParameters = TransferTypeParameters(articleItemYaml.Syntax);
member.Uid = articleItemYaml.Uid;
return(member);
}
protected abstract void FillLanguageSpecificMetadata(ArticleItemYaml yaml, ArticleContext context, XElement node);
protected void FillOverridden(ArticleItemYaml yaml, XElement node)
{
yaml.Overridden = node.NullableElement("reimplements").NullableAttribute("refid").NullableValue();
}
public abstract string GenerateInheritImplementString(IReadOnlyDictionary <string, ArticleItemYaml> articleDict, ArticleItemYaml yaml);
public override string GenerateInheritImplementString(IReadOnlyDictionary <string, ArticleItemYaml> articleDict, ArticleItemYaml yaml)
{
if (yaml.ImplementsOrInherits == null || yaml.ImplementsOrInherits.Count == 0)
{
return(string.Empty);
}
List <string> implements = new List <string>();
List <string> extends = new List <string>();
foreach (var ele in yaml.ImplementsOrInherits)
{
ArticleItemYaml eleYaml;
if (articleDict.TryGetValue(ele.Type, out eleYaml))
{
string parent = eleYaml.Parent != null ? articleDict[eleYaml.Parent].FullName : string.Empty;
string name = YamlUtility.ParseNameFromFullName(HierarchyType.Class, parent, ele.SpecializedFullName, Constants.Dot);
if (yaml.Type != MemberType.Interface && eleYaml.Type == MemberType.Interface)
{
implements.Add(name);
}
else
{
extends.Add(name);
}
}
}
var builder = new StringBuilder();
if (extends.Count > 0)
{
builder.Append($" extends {extends[0]}");
foreach (var ex in extends.Skip(1))
{
builder.Append($",{ex}");
}
}
if (implements.Count > 0)
{
builder.Append($" implements {implements[0]}");
foreach (var im in implements.Skip(1))
{
builder.Append($",{im}");
}
}
return(builder.ToString());
}
protected abstract IEnumerable <string> GetDefaultInheritance(ArticleItemYaml yaml);
public Task <PageModel> GenerateArticleAsync(BuildContext context, XDocument document)
{
PageModel page = new PageModel()
{
Items = new List <ArticleItemYaml>()
};
ArticleItemYaml mainYaml = new ArticleItemYaml();
page.Items.Add(mainYaml);
var articleContext = new ArticleContext(context);
HierarchyChange curChange = articleContext.CurrentChange;
HierarchyChange parentChange = articleContext.ParentChange;
var nameContext = new NameGeneratorContext {
CurrentChange = curChange, ParentChange = parentChange
};
var main = document.Root.NullableElement("compounddef");
mainYaml.Uid = curChange.Uid;
mainYaml.Id = _nameGenerator.GenerateId(nameContext, main);
mainYaml.SupportedLanguages = new string[] { Language };
mainYaml.FullName = _nameGenerator.GenerateTypeFullName(nameContext, main, true);
mainYaml.Name = _nameGenerator.GenerateTypeName(nameContext, main, true);
mainYaml.NameWithType = mainYaml.Name;
mainYaml.FullNameWithoutTypeParameter = _nameGenerator.GenerateTypeFullName(nameContext, main, false);
mainYaml.NameWithoutTypeParameter = _nameGenerator.GenerateTypeName(nameContext, main, false);
mainYaml.Href = YamlUtility.ParseHrefFromChangeFile(curChange.File);
mainYaml.Type = YamlUtility.ParseType(curChange.Type.ToString());
mainYaml.Parent = curChange.Parent;
mainYaml.Children = curChange.Children != null ? new List <string>(curChange.Children.OrderBy(c => c)) : new List <string>();
FillSummary(mainYaml, main);
FillRemarks(mainYaml, main);
FillSource(mainYaml, main);
FillSees(mainYaml, main);
FillException(mainYaml, main);
FillInheritance(nameContext, mainYaml, main);
FillSyntax(mainYaml, main, isMain: true);
FillImplementsOrInherits(mainYaml, main);
FillLanguageSpecificMetadata(mainYaml, articleContext, main);
var members = new Dictionary <string, ArticleItemYaml>();
foreach (var section in main.Elements("sectiondef"))
{
string kind = section.NullableAttribute("kind").NullableValue();
var tuple = KindMapToType(kind);
if (tuple.Item1.HasValue && ((tuple.Item2 & AccessLevel.NotAccessible) == AccessLevel.None))
{
foreach (var member in section.Elements("memberdef"))
{
var memberYaml = new ArticleItemYaml();
memberYaml.Uid = member.NullableAttribute("id").NullableValue();
memberYaml.Id = _nameGenerator.GenerateId(nameContext, member);
memberYaml.SupportedLanguages = new string[] { Language };
memberYaml.FullName = _nameGenerator.GenerateMemberFullName(nameContext, member);
memberYaml.Name = _nameGenerator.GenerateMemberName(nameContext, member);
memberYaml.NameWithType = _nameGenerator.GenerateMemberNameWithType(memberYaml.Name, mainYaml.Name);
memberYaml.Href = mainYaml.Href;
memberYaml.Type = string.IsNullOrEmpty(member.NullableElement("type").NullableValue()) && tuple.Item1.Value == MemberType.Method ? MemberType.Constructor : tuple.Item1.Value;
memberYaml.Parent = mainYaml.Uid;
FillSummary(memberYaml, member);
FillRemarks(memberYaml, member);
FillSource(memberYaml, member);
FillSees(memberYaml, member);
FillException(memberYaml, member);
FillOverridden(memberYaml, member);
FillSyntax(memberYaml, member, isMain: false);
FillLanguageSpecificMetadata(memberYaml, articleContext, member);
FillOverload(memberYaml, member);
if (members.ContainsKey(memberYaml.Uid))
{
ConsoleLogger.WriteLine(
new LogEntry
{
Phase = "GenerateArticles",
Level = LogLevel.Warning,
Message = $"Duplicate items {memberYaml.Uid} found in {curChange.File}.",
});
continue;
}
members[memberYaml.Uid] = memberYaml;
EmptyToNull(memberYaml);
}
}
}
mainYaml.Children.AddRange(from p in members
orderby p.Value.Name.ToLower()
select p.Key);
page.Items.AddRange(from i in members.Values
orderby i.Name.ToLower()
select i);
// after children are filled, fill inherited members
FillInheritedMembers(mainYaml, main);
FillReferences(page, document, articleContext);
EmptyToNull(mainYaml);
return(Task.FromResult(page));
}
