private static XmlNodeSyntax[] CreateParamenterXmlDocumentation(XmlTextSyntax xmlText, string paramenterName, string methodName)
{
var content = $"todo: describe {paramenterName} parameter on {methodName}";
var xmlTagName = SyntaxFactory.XmlName(SyntaxFactory.Identifier(@"param "));
var startTag = SyntaxFactory.XmlElementStartTag(xmlTagName).WithAttributes(CreateXmlAttributes(paramenterName));
var endTag = SyntaxFactory.XmlElementEndTag(SyntaxFactory.XmlName(SyntaxFactory.Identifier(@"param")));
var xmlElementSyntax = SyntaxFactory.XmlElement(startTag, endTag).WithContent(CreateXmlElementContent(content));
return new XmlNodeSyntax[] { xmlText, xmlElementSyntax };
}
public override void VisitXmlText(XmlTextSyntax node)
{
var nodeLine = node.SyntaxTree.GetLineSpan(node.Span).StartLinePosition.Line;
var line = _lineNumberOverride ?? nodeLine;
var text = node.TextTokens
.Where(n => n.Kind() == SyntaxKind.XmlTextLiteralToken)
.Aggregate(new StringBuilder(), (a, t) => a.AppendLine(t.Text.TrimStart()), a => a.ToString());
this.TextBlocks.Add(new TextBlock(text, line));
base.VisitXmlText(node);
}
public override void VisitXmlText(XmlTextSyntax node)
{
base.VisitXmlText(node);
}
public override SyntaxNode VisitXmlText(XmlTextSyntax node)
{
node = (XmlTextSyntax)base.VisitXmlText(node);
Classes.Add(node);
return(node);
}
private static bool TextPartsMatch(string firstText, string secondText, XmlTextSyntax firstTextPart, XmlTextSyntax secondTextPart)
{
string firstTextPartText = XmlCommentHelper.GetText(firstTextPart, normalizeWhitespace: true);
if (firstText != firstTextPartText.TrimStart())
{
return(false);
}
string secondTextPartText = XmlCommentHelper.GetText(secondTextPart, normalizeWhitespace: true);
return(secondTextPartText.StartsWith(secondText, StringComparison.Ordinal));
}
protected string ReadText(XmlTextSyntax textItem)
{
var texts = textItem.TextTokens.Select(t => t.ValueText.Trim()).Where(txt => !string.IsNullOrEmpty(txt));
return(string.Join(Environment.NewLine, texts.ToList()));
}
private bool TryRemoveSummaryPrefix(ref SyntaxList <XmlNodeSyntax> summaryContent, string prefix)
{
XmlNodeSyntax firstContent = summaryContent.FirstOrDefault(IsContentElement);
XmlTextSyntax firstText = firstContent as XmlTextSyntax;
if (firstText == null)
{
return(false);
}
string firstTextContent = string.Concat(firstText.DescendantTokens());
if (!firstTextContent.TrimStart().StartsWith(prefix, StringComparison.Ordinal))
{
return(false);
}
// Find the token containing the prefix, such as "Gets or sets "
SyntaxToken prefixToken = default(SyntaxToken);
foreach (SyntaxToken textToken in firstText.TextTokens)
{
if (textToken.IsMissing)
{
continue;
}
if (!textToken.Text.TrimStart().StartsWith(prefix, StringComparison.Ordinal))
{
continue;
}
prefixToken = textToken;
break;
}
if (prefixToken.IsMissingOrDefault())
{
return(false);
}
string text = prefixToken.Text;
string valueText = prefixToken.ValueText;
int index = text.IndexOf(prefix);
if (index >= 0)
{
bool additionalCharacters = index + prefix.Length < text.Length;
text = text.Substring(0, index)
+ (additionalCharacters ? char.ToUpperInvariant(text[index + prefix.Length]).ToString() : string.Empty)
+ text.Substring(index + (additionalCharacters ? (prefix.Length + 1) : prefix.Length));
}
index = valueText.IndexOf(prefix);
if (index >= 0)
{
valueText = valueText.Remove(index, prefix.Length);
}
SyntaxToken replaced = SyntaxFactory.Token(prefixToken.LeadingTrivia, prefixToken.Kind(), text, valueText, prefixToken.TrailingTrivia);
summaryContent = summaryContent.Replace(firstText, firstText.ReplaceToken(prefixToken, replaced));
return(true);
}
public override void VisitXmlText(XmlTextSyntax node)
{
Debug.Fail(node.ToString());
base.VisitXmlText(node);
}
private void ClassifyXmlText(XmlTextSyntax node)
{
ClassifyXmlTextTokens(node.TextTokens);
}
public override Evaluation VisitXmlText(XmlTextSyntax node)
{
return(base.VisitXmlText(node));
}
private static XmlElementSyntax TrimWhitespaceContent(XmlElementSyntax paragraph, out SyntaxList <XmlNodeSyntax> leadingWhitespaceContent, out SyntaxList <XmlNodeSyntax> trailingWhitespaceContent)
{
SyntaxList <XmlNodeSyntax> completeContent = XmlSyntaxFactory.List(paragraph.Content.SelectMany(ExpandTextNodes).ToArray());
leadingWhitespaceContent = XmlSyntaxFactory.List(completeContent.TakeWhile(x => XmlCommentHelper.IsConsideredEmpty(x)).ToArray());
trailingWhitespaceContent = XmlSyntaxFactory.List(completeContent.Skip(leadingWhitespaceContent.Count).Reverse().TakeWhile(x => XmlCommentHelper.IsConsideredEmpty(x)).Reverse().ToArray());
SyntaxList <XmlNodeSyntax> trimmedContent = XmlSyntaxFactory.List(completeContent.Skip(leadingWhitespaceContent.Count).Take(completeContent.Count - leadingWhitespaceContent.Count - trailingWhitespaceContent.Count).ToArray());
SyntaxTriviaList leadingTrivia = SyntaxFactory.TriviaList();
SyntaxTriviaList trailingTrivia = SyntaxFactory.TriviaList();
if (trimmedContent.Any())
{
leadingTrivia = trimmedContent[0].GetLeadingTrivia();
trailingTrivia = trimmedContent.Last().GetTrailingTrivia();
trimmedContent = trimmedContent.Replace(trimmedContent[0], trimmedContent[0].WithoutLeadingTrivia());
trimmedContent = trimmedContent.Replace(trimmedContent.Last(), trimmedContent.Last().WithoutTrailingTrivia());
}
else
{
leadingTrivia = SyntaxFactory.TriviaList();
trailingTrivia = SyntaxFactory.TriviaList();
}
XmlElementSyntax result = paragraph;
if (leadingWhitespaceContent.Any())
{
var first = leadingWhitespaceContent[0];
var newFirst = first.WithLeadingTrivia(first.GetLeadingTrivia().InsertRange(0, paragraph.GetLeadingTrivia()));
leadingWhitespaceContent = leadingWhitespaceContent.Replace(first, newFirst);
}
else
{
leadingTrivia = leadingTrivia.InsertRange(0, result.GetLeadingTrivia());
}
if (trailingWhitespaceContent.Any())
{
var last = trailingWhitespaceContent.Last();
var newLast = last.WithLeadingTrivia(last.GetLeadingTrivia().AddRange(paragraph.GetTrailingTrivia()));
trailingWhitespaceContent = trailingWhitespaceContent.Replace(last, newLast);
}
else
{
trailingTrivia = trailingTrivia.AddRange(result.GetTrailingTrivia());
}
if (trimmedContent.FirstOrDefault() is XmlTextSyntax firstTextNode &&
firstTextNode.TextTokens.Any())
{
SyntaxToken firstTextToken = firstTextNode.TextTokens[0];
string leadingWhitespace = new string(firstTextToken.Text.Cast <char>().TakeWhile(char.IsWhiteSpace).ToArray());
if (leadingWhitespace.Length > 0)
{
SyntaxToken newFirstTextToken = XmlSyntaxFactory.TextLiteral(firstTextToken.Text.Substring(leadingWhitespace.Length)).WithTriviaFrom(firstTextToken);
XmlTextSyntax newFirstTextNode = firstTextNode.WithTextTokens(firstTextNode.TextTokens.Replace(firstTextToken, newFirstTextToken));
trimmedContent = trimmedContent.Replace(firstTextNode, newFirstTextNode);
leadingTrivia = leadingTrivia.Add(SyntaxFactory.Whitespace(leadingWhitespace));
}
}
if (trimmedContent.LastOrDefault() is XmlTextSyntax lastTextNode &&
lastTextNode.TextTokens.Any())
{
SyntaxToken lastTextToken = lastTextNode.TextTokens.Last();
string trailingWhitespace = new string(lastTextToken.Text.Cast <char>().Reverse().TakeWhile(char.IsWhiteSpace).Reverse().ToArray());
if (trailingWhitespace.Length > 0)
{
SyntaxToken newLastTextToken = XmlSyntaxFactory.TextLiteral(lastTextToken.Text.Substring(0, lastTextToken.Text.Length - trailingWhitespace.Length)).WithTriviaFrom(lastTextToken);
XmlTextSyntax newLastTextNode = lastTextNode.WithTextTokens(lastTextNode.TextTokens.Replace(lastTextToken, newLastTextToken));
trimmedContent = trimmedContent.Replace(lastTextNode, newLastTextNode);
trailingTrivia = trailingTrivia.Insert(0, SyntaxFactory.Whitespace(trailingWhitespace));
}
}
return(result.WithContent(trimmedContent)
.WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(trailingTrivia));
}
protected override ITagCommentReaderState AcceptXmlText(XmlTextSyntax syntax)
{
StateMachine.AddText(Environment.NewLine);
StateMachine.AddText(ReadText(syntax));
return(this);
}
private void FormatXmlText(XmlTextSyntax node)
{
FormatTextTokens(node.TextTokens);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitXmlText(XmlTextSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitXmlText(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitXmlText(XmlTextSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitXmlText(node);
}
protected abstract ITagCommentReaderState AcceptXmlText(XmlTextSyntax syntax);
internal static string GetText(XmlTextSyntax textElement)
{
return(GetText(textElement, false));
}
public TameXmlTextSyntax(XmlTextSyntax node)
{
Node = node;
AddChildren();
}
protected override ITagCommentReaderState AcceptXmlText(XmlTextSyntax syntax)
{
StateMachine.AddText(ReadText(syntax));
return(new TagCommentReaderNewLineState(StateMachine));
}
private static bool TextPartsMatch(string firstText, string secondText, XmlTextSyntax firstTextPart, XmlTextSyntax secondTextPart)
{
string firstTextPartText = XmlCommentHelper.GetText(firstTextPart, normalizeWhitespace: true);
if (firstText != firstTextPartText.TrimStart())
{
return false;
}
string secondTextPartText = XmlCommentHelper.GetText(secondTextPart, normalizeWhitespace: true);
if (!secondTextPartText.StartsWith(secondText, StringComparison.Ordinal))
{
return false;
}
return true;
}
private void ClassifyXmlText(XmlTextSyntax node) => ClassifyXmlTextTokens(node.TextTokens);
// // Summary: // Called when the visitor visits a XmlTextSyntax node. public virtual void VisitXmlText(XmlTextSyntax node);
public override void VisitXmlText(XmlTextSyntax node)
{
}
public override void VisitXmlText(XmlTextSyntax node)
{
var tokens = node.TextTokens
.Where(n => n.Kind() == SyntaxKind.XmlTextLiteralToken || n.Kind() == SyntaxKind.XmlEntityLiteralToken)
.ToList();
var builder = new StringBuilder();
for (int index = 0; index < tokens.Count; index++)
{
var token = tokens[index];
if (token.Kind() == SyntaxKind.XmlEntityLiteralToken ||
(index + 1 < tokens.Count && tokens[index + 1].Kind() == SyntaxKind.XmlEntityLiteralToken))
{
builder.Append(token.Text.Trim());
}
else
{
builder.AppendLine(token.Text.Trim());
}
}
var text = builder.ToString();
var line = node.SyntaxTree.GetLineSpan(node.Span).StartLinePosition.Line;
this.Blocks.Add(new TextBlock(text, line));
base.VisitXmlText(node);
}
public static SyntaxList <XmlNodeSyntax> WithoutFirstAndLastNewlines(this SyntaxList <XmlNodeSyntax> summaryContent)
{
if (summaryContent.Count == 0)
{
return(summaryContent);
}
XmlTextSyntax firstSyntax = summaryContent[0] as XmlTextSyntax;
if (firstSyntax == null)
{
return(summaryContent);
}
XmlTextSyntax lastSyntax = summaryContent[summaryContent.Count - 1] as XmlTextSyntax;
if (lastSyntax == null)
{
return(summaryContent);
}
SyntaxTokenList firstSyntaxTokens = firstSyntax.TextTokens;
int removeFromStart;
if (IsXmlNewLine(firstSyntaxTokens[0]))
{
removeFromStart = 1;
}
else
{
if (!IsXmlWhitespace(firstSyntaxTokens[0]))
{
return(summaryContent);
}
if (!IsXmlNewLine(firstSyntaxTokens[1]))
{
return(summaryContent);
}
removeFromStart = 2;
}
SyntaxTokenList lastSyntaxTokens = lastSyntax.TextTokens;
int removeFromEnd;
if (IsXmlNewLine(lastSyntaxTokens[lastSyntaxTokens.Count - 1]))
{
removeFromEnd = 1;
}
else
{
if (!IsXmlWhitespace(lastSyntaxTokens[lastSyntaxTokens.Count - 1]))
{
return(summaryContent);
}
if (!IsXmlNewLine(lastSyntaxTokens[lastSyntaxTokens.Count - 2]))
{
return(summaryContent);
}
removeFromEnd = 2;
}
for (int i = 0; i < removeFromStart; i++)
{
firstSyntaxTokens = firstSyntaxTokens.RemoveAt(0);
}
if (firstSyntax == lastSyntax)
{
lastSyntaxTokens = firstSyntaxTokens;
}
for (int i = 0; i < removeFromEnd; i++)
{
lastSyntaxTokens = lastSyntaxTokens.RemoveAt(lastSyntaxTokens.Count - 1);
}
summaryContent = summaryContent.RemoveAt(summaryContent.Count - 1);
if (lastSyntaxTokens.Count != 0)
{
summaryContent = summaryContent.Add(lastSyntax.WithTextTokens(lastSyntaxTokens));
}
if (firstSyntax != lastSyntax)
{
summaryContent = summaryContent.RemoveAt(0);
if (firstSyntaxTokens.Count != 0)
{
summaryContent = summaryContent.Insert(0, firstSyntax.WithTextTokens(firstSyntaxTokens));
}
}
if (summaryContent.Count > 0)
{
// Make sure to remove the leading trivia
summaryContent = summaryContent.Replace(summaryContent[0], summaryContent[0].WithLeadingTrivia());
// Remove leading spaces (between the <para> start tag and the start of the paragraph content)
XmlTextSyntax firstTextSyntax = summaryContent[0] as XmlTextSyntax;
if (firstTextSyntax != null && firstTextSyntax.TextTokens.Count > 0)
{
SyntaxToken firstTextToken = firstTextSyntax.TextTokens[0];
string firstTokenText = firstTextToken.Text;
string trimmed = firstTokenText.TrimStart();
if (trimmed != firstTokenText)
{
SyntaxToken newFirstToken = SyntaxFactory.Token(
firstTextToken.LeadingTrivia,
firstTextToken.Kind(),
trimmed,
firstTextToken.ValueText.TrimStart(),
firstTextToken.TrailingTrivia);
summaryContent = summaryContent.Replace(firstTextSyntax, firstTextSyntax.ReplaceToken(firstTextToken, newFirstToken));
}
}
}
return(summaryContent);
}
public override void VisitXmlText(XmlTextSyntax node)
{
throw new NotSupportedException();
}
