protected override IEnumerable <Diagnostic> AnalyzeField(IFieldSymbol symbol, string commentXml)
{
if (commentXml.IsNullOrWhiteSpace())
{
return(Enumerable.Empty <Diagnostic>());
}
var symbolName = symbol.Name;
if (symbolName.EndsWith(Constants.DependencyPropertyFieldSuffix, StringComparison.OrdinalIgnoreCase) is false)
{
return(Enumerable.Empty <Diagnostic>());
}
var propertyName = symbolName.WithoutSuffix(Constants.DependencyPropertyFieldSuffix);
var containingType = symbol.ContainingType;
if (containingType.GetMembersIncludingInherited <IPropertySymbol>().All(_ => _.Name != propertyName))
{
// it's an unknown dependency property
return(Enumerable.Empty <Diagnostic>());
}
List <Diagnostic> results = null;
var containingTypeFullName = containingType.ToString();
// loop over phrases for summaries and values
ValidatePhrases(symbol, CommentExtensions.GetSummaries(commentXml), () => Phrases(Constants.Comments.DependencyPropertyFieldSummaryPhrase, containingTypeFullName, propertyName), Constants.XmlTag.Summary, ref results);
ValidatePhrases(symbol, CommentExtensions.GetValue(commentXml), () => Phrases(Constants.Comments.DependencyPropertyFieldValuePhrase, containingTypeFullName, propertyName), Constants.XmlTag.Value, ref results);
return(results ?? Enumerable.Empty <Diagnostic>());
}
public void Can_build_node_sorted()
{
// arrange
var sub = new Sub();
sub.Id = GuidUtil.NewSequentialId();
sub.Name = "test";
var author = new User();
author.Id = GuidUtil.NewSequentialId();
author.UserName = "******";
var comments = ConvertTestNodesToComments(new List <TestNodeTreeSorted>
{
TestNodeTreeSorted.Create(10,
TestNodeTreeSorted.Create(5),
TestNodeTreeSorted.Create(4,
TestNodeTreeSorted.Create(2),
TestNodeTreeSorted.Create(20))),
TestNodeTreeSorted.Create(9,
TestNodeTreeSorted.Create(3,
TestNodeTreeSorted.Create(1)),
TestNodeTreeSorted.Create(12))
});
foreach (var comment in comments)
{
comment.SubId = sub.Id;
comment.AuthorUserId = author.Id;
}
SetupComments(comments);
_membershipService.Setup(x => x.GetUsersByIds(It.IsAny <List <Guid> >())).Returns(new List <User> {
author
});
_subDao.Setup(x => x.GetSubsByIds(It.IsAny <List <Guid> >())).Returns(new List <Sub> {
sub
});
// act
var tree = _commentTreeBuilder.GetCommentTree(Guid.Empty);
var treeContext = _commentTreeContextBuilder.Build(tree,
comments.ToDictionary(x => x.Id, x => (double)x.SortConfidence));
var nodes = _commentNodeHierarchyBuilder.Build(tree, treeContext, null);
//assert
nodes.Count.Should().Be(2);
CommentExtensions.As <CommentNode>(nodes[0]).Comment.Comment.SortConfidence.Should().Be(10);
CommentExtensions.As <CommentNode>(nodes[0]).Children.Count.Should().Be(2);
CommentExtensions.As <CommentNode>(nodes[0].As <CommentNode>().Children[0]).Comment.Comment.SortConfidence.Should().Be(5);
CommentExtensions.As <CommentNode>(nodes[0].As <CommentNode>().Children[1]).Comment.Comment.SortConfidence.Should().Be(4);
CommentExtensions.As <CommentNode>(nodes[0]).Children[1].Children.Count.Should().Be(2);
CommentExtensions.As <CommentNode>(nodes[0].As <CommentNode>().Children[1].Children[0]).Comment.Comment.SortConfidence.Should().Be(20);
CommentExtensions.As <CommentNode>(nodes[0].As <CommentNode>().Children[1].Children[1]).Comment.Comment.SortConfidence.Should().Be(2);
CommentExtensions.As <CommentNode>(nodes[1]).Comment.Comment.SortConfidence.Should().Be(9);
CommentExtensions.As <CommentNode>(nodes[1]).Children.Count.Should().Be(2);
CommentExtensions.As <CommentNode>(nodes[1].As <CommentNode>().Children[0]).Comment.Comment.SortConfidence.Should().Be(12);
CommentExtensions.As <CommentNode>(nodes[1].As <CommentNode>().Children[1]).Comment.Comment.SortConfidence.Should().Be(3);
CommentExtensions.As <CommentNode>(nodes[1]).Children[1].Children.Count.Should().Be(1);
CommentExtensions.As <CommentNode>(nodes[1].As <CommentNode>().Children[1].Children[0]).Comment.Comment.SortConfidence.Should().Be(1);
}
protected override IEnumerable <Diagnostic> AnalyzeComment(ISymbol symbol, string commentXml)
{
if (commentXml.IsNullOrWhiteSpace())
{
return(Enumerable.Empty <Diagnostic>());
}
var comments = CommentExtensions.GetExamples(commentXml).ToArray();
return(AnalyzeExample(symbol, comments));
}
protected override IEnumerable <Diagnostic> AnalyzeComment(ISymbol symbol, string commentXml)
{
if (commentXml.IsNullOrWhiteSpace() is false)
{
var groups = CommentExtensions.GetExceptionsOfExceptionComments(commentXml)
.GroupBy(_ => _); // TODO: what about namespaces
foreach (var g in groups.Where(_ => _.Count() > 1))
{
yield return(Issue(symbol, g.Key));
}
}
}
protected IEnumerable <Diagnostic> AnalyzeSummaries(ISymbol symbol, string commentXml)
{
if (commentXml.IsNullOrWhiteSpace())
{
return(Enumerable.Empty <Diagnostic>());
}
var summaries = CommentExtensions.GetSummaries(commentXml);
return(summaries.Any()
? AnalyzeSummary(symbol, summaries)
: Enumerable.Empty <Diagnostic>());
}
protected override IEnumerable <Diagnostic> AnalyzeComment(ISymbol symbol, string commentXml)
{
if (commentXml.IsNullOrWhiteSpace())
{
return(Enumerable.Empty <Diagnostic>());
}
var results = CommentExtensions.GetExceptionComments(commentXml)
.Where(_ => _.StartsWithAny(Constants.Comments.ExceptionForbiddenStartingPhrase))
.Select(_ => Issue(symbol))
.ToList();
return(results);
}
protected override IEnumerable <Diagnostic> AnalyzeComment(ISymbol symbol, string commentXml)
{
foreach (var xmlTag in XmlTags)
{
foreach (var unused in CommentExtensions.GetCommentElements(commentXml, xmlTag)
.Select(_ => _.Nodes().ConcatenatedWith().TrimStart())
.Select(_ => _.Without(Constants.Comments.SpecialOrPhrase))
.Where(_ => _.Length > 0)
.Where(_ => _[0].IsUpperCase() is false && _[0] != Constants.Comments.XmlElementStartingTag[0]))
{
yield return(Issue(symbol, xmlTag));
}
}
}
private IEnumerable <Diagnostic> TryAnalyzeReturnType(ISymbol owningSymbol, ITypeSymbol returnType, string commentXml, string xmlTag)
{
List <Diagnostic> results = null;
foreach (var comment in CommentExtensions.GetComments(commentXml, xmlTag).Where(_ => _ != null))
{
var findings = AnalyzeReturnType(owningSymbol, returnType, comment, xmlTag);
if (findings.Any())
{
if (results is null)
{
results = new List <Diagnostic>(findings.Count());
}
results.AddRange(findings);
}
}
return(results);
}
protected override IEnumerable <Diagnostic> AnalyzeMethod(IMethodSymbol symbol, string commentXml)
{
if (commentXml.IsNullOrWhiteSpace())
{
return(Enumerable.Empty <Diagnostic>());
}
var summaries = CommentExtensions.GetSummaries(commentXml);
var results = summaries.Any() && summaries.All(_ => _ != SummaryPhrase)
? new List <Diagnostic>(1)
{
Issue(symbol, SummaryPhrase)
}
: null;
// check for parameter
foreach (var parameter in symbol.Parameters)
{
var comment = parameter.GetComment(commentXml);
switch (comment)
{
case null:
case ParameterPhrase:
continue;
}
if (results is null)
{
results = new List <Diagnostic>(1);
}
results.Add(Issue(parameter, ParameterPhrase));
}
return(results ?? Enumerable.Empty <Diagnostic>());
}
private static bool TagCommentHasIssue(string commentXml, string xmlTag) => CommentExtensions.GetCommentElements(commentXml, xmlTag).SelectMany(_ => _.Nodes()).Any(CommentHasIssue);
