Exemple #1
0
        private SDToken GetSeeRef(XmlDocumentationElement xmlElement)
        {
            try
            {
                var sdToken = new SDSeeToken();

                if (xmlElement.ReferencedEntity != null)
                {
                    var identifier = xmlElement.ReferencedEntity.DeclaringType != null
                                            ? xmlElement.ReferencedEntity.DeclaringType.GetIdentifier()
                                            : string.Empty;

                    sdToken.Name          = xmlElement.ReferencedEntity.Name;
                    sdToken.Namespace     = xmlElement.ReferencedEntity.Namespace;
                    sdToken.DeclaringType = identifier;
                    sdToken.Text          = xmlElement.ReferencedEntity.Name;
                }
                else
                {
                    sdToken.Name = xmlElement.GetAttribute("cref");
                }

                return(sdToken);
            }
            catch (Exception)
            {
                return(null);
            }
        }
        protected override object CreateFancyDescription()
        {
            var ambience = new CSharpAmbience();

            ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowDeclaringType;
            string header        = ambience.ConvertSymbol(Entity);
            var    documentation = XmlDocumentationElement.Get(Entity);

            ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
            var b = new CSharpDocumentationBuilder(ambience);

            b.AddCodeBlock(header, keepLargeMargin: true);
            if (documentation != null)
            {
                foreach (var child in documentation.Children)
                {
                    b.AddDocumentationElement(child);
                }
            }

            var flowDocument = b.CreateFlowDocument();

            flowDocument.PagePadding = new Thickness(0); // default is NOT Thickness(0), but Thickness(Auto), which adds unnecessary space

            return(new FlowDocumentScrollViewer {
                Document = flowDocument,
                VerticalScrollBarVisibility = ScrollBarVisibility.Auto
            });
        }
Exemple #3
0
        private SDTokenList ParseContentTokens(XmlDocumentationElement xmlElement)
        {
            var content = new SDTokenList();

            foreach (XmlDocumentationElement element in xmlElement.Children)
            {
                var text = Regex.Replace(element.TextContent, "^[ ]{4}", "", RegexOptions.Multiline);

                if (element.IsTextNode)
                {
                    content.Add(new SDToken {
                        Role = SDTokenRole.Text, Text = text
                    });
                }
                else
                {
                    switch (element.Name.ToLower())
                    {
                    case "see":
                        var seeRef = GetSeeRef(element);
                        if (seeRef != null)
                        {
                            content.Add(seeRef);
                        }
                        break;

                    case "typeparamref":
                        content.Add(new SDToken {
                            Role = SDTokenRole.TypeParamRef, Text = element.GetAttribute("name")
                        });
                        break;

                    case "paramref":
                        content.Add(new SDToken {
                            Role = SDTokenRole.ParamRef, Text = element.GetAttribute("name")
                        });
                        break;

                    case "code":
                        content.Add(new SDCodeToken {
                            Text = text, IsInline = false
                        });
                        break;

                    case "c":
                        content.Add(new SDCodeToken {
                            Text = text, IsInline = true
                        });
                        break;

                    case "para":
                        content.Add(new SDToken {
                            Text = text, Role = SDTokenRole.Paragraph
                        });
                        break;
                    }
                }
            }
            return(content);
        }
        public static FlowDocument CreateTooltip(IEntity entity, bool useFullyQualifiedMemberNames = true)
        {
            var ambience = AmbienceService.GetCurrentAmbience();

            ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowDeclaringType;
            if (useFullyQualifiedMemberNames)
            {
                ambience.ConversionFlags |= ConversionFlags.UseFullyQualifiedEntityNames;
            }
            string header        = ambience.ConvertSymbol(entity);
            var    documentation = XmlDocumentationElement.Get(entity);

            ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
            DocumentationUIBuilder b = new DocumentationUIBuilder(ambience);

            b.AddCodeBlock(header, keepLargeMargin: true);
            if (documentation != null)
            {
                foreach (var child in documentation.Children)
                {
                    b.AddDocumentationElement(child);
                }
            }
            return(b.CreateFlowDocument());
        }
Exemple #5
0
 private void AddResultsSection(Dictionary <string, SDTokenList> results, XmlDocumentationElement xmlElement)
 {
     if (!string.IsNullOrEmpty(xmlElement.GetAttribute("httpCode")))
     {
         results.Add(xmlElement.GetAttribute("httpCode"), ParseContentTokens(xmlElement));
     }
     else if (!results.ContainsKey("default"))
     {
         results.Add("default", ParseContentTokens(xmlElement));
     }
 }
Exemple #6
0
        public void CDATAInDocumentation()
        {
            Init(@"using System;
/// <summary>before<![CDATA[<xml/>]]>after</summary>
class Test { }
");
            var element = XmlDocumentationElement.Get(typeDefinition);

            Assert.AreEqual(1, element.Children.Count());
            Assert.AreEqual("summary", element.Children[0].Name);
            Assert.AreEqual("before<xml/>after", element.Children[0].TextContent);
        }
Exemple #7
0
        protected override CodeAction GetAction(RefactoringContext context, ThrowStatement node)
        {
            var entity = node.GetParent <EntityDeclaration> ();

            if (entity == null)
            {
                return(null);
            }
            var rr = context.Resolve(entity) as MemberResolveResult;

            if (rr == null || rr.IsError)
            {
                return(null);
            }
            var expr = context.Resolve(node.Expression);

            if (expr == null || expr.IsError || expr.Type.GetDefinition() == null)
            {
                return(null);
            }

            var docElement = XmlDocumentationElement.Get(rr.Member);

            if (docElement == null || docElement.Children.Count == 0)
            {
                return(null);
            }
            foreach (var de in docElement.Children)
            {
                if (de.Name == "exception")
                {
                    if (de.ReferencedEntity == expr.Type)
                    {
                        return(null);
                    }
                }
            }

            return(new CodeAction(
                       context.TranslateString("Add exception to xml documentation"),
                       script => {
                var startText = string.Format(" <exception cref=\"{0}\">", expr.Type.GetDefinition().GetIdString());
                var comment = new Comment(startText + "</exception>", CommentType.Documentation);
                script.InsertBefore(
                    SearchInsertionNode(entity.FirstChild) ?? entity,
                    comment
                    );
                script.Select(script.GetSegment(comment).Offset + ("///" + startText).Length, 0);
            },
                       node
                       ));
        }
Exemple #8
0
        void AddSee(XmlDocumentationElement element)
        {
            IEntity referencedEntity = element.ReferencedEntity;

            if (referencedEntity != null)
            {
                if (element.Children.Any())
                {
                    Hyperlink link = new Hyperlink();
                    link.Click += (sender, e) => {
                        MainWindow.Instance.JumpToReference(referencedEntity);
                    };
                    AddSpan(link, element.Children);
                }
                else
                {
                    AddInline(ConvertReference(referencedEntity));
                }
            }
            else if (element.GetAttribute("langword") != null)
            {
                AddInline(new Run(element.GetAttribute("langword"))
                {
                    FontFamily = GetCodeFont()
                });
            }
            else if (element.GetAttribute("href") != null)
            {
                Uri uri;
                if (Uri.TryCreate(element.GetAttribute("href"), UriKind.Absolute, out uri))
                {
                    if (element.Children.Any())
                    {
                        AddSpan(new Hyperlink {
                            NavigateUri = uri
                        }, element.Children);
                    }
                    else
                    {
                        AddInline(new Hyperlink(new Run(element.GetAttribute("href")))
                        {
                            NavigateUri = uri
                        });
                    }
                }
            }
            else
            {
                // Invalid reference: print the cref value
                AddText(element.GetAttribute("cref"));
            }
        }
        FlowDocumentScrollViewer GenerateHeader()
        {
            var ambience = new CSharpAmbience();

            ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
            var stringBuilder = new StringBuilder();
            var formatter     = new ParameterHighlightingOutputFormatter(stringBuilder, highlightedParameterIndex);

            ambience.ConvertSymbol(Method, formatter, FormattingOptionsFactory.CreateSharpDevelop());

            var documentation = XmlDocumentationElement.Get(Method);

            ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;

            var    b             = new CSharpDocumentationBuilder(ambience);
            string parameterName = null;

            if (Method.Parameters.Count > highlightedParameterIndex)
            {
                parameterName = Method.Parameters[highlightedParameterIndex].Name;
            }
            b.AddSignatureBlock(stringBuilder.ToString(), formatter.parameterStartOffset, formatter.parameterLength, parameterName);

            var b2 = new CSharpDocumentationBuilder(ambience);

            b2.ParameterName     = parameterName;
            b2.ShowAllParameters = false;

            if (documentation != null)
            {
                foreach (var child in documentation.Children)
                {
                    b2.AddDocumentationElement(child);
                }
            }

            content = new FlowDocumentScrollViewer {
                Document = b2.CreateFlowDocument(),
                VerticalScrollBarVisibility = ScrollBarVisibility.Auto
            };

            var flowDocument = b.CreateFlowDocument();

            flowDocument.PagePadding = new Thickness(0); // default is NOT Thickness(0), but Thickness(Auto), which adds unnecessary space

            return(new FlowDocumentScrollViewer {
                Document = flowDocument,
                VerticalScrollBarVisibility = ScrollBarVisibility.Auto
            });
        }
        void GenerateHeader()
        {
            CSharpAmbience ambience = new CSharpAmbience();

            ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
            var         stringBuilder = new StringBuilder();
            TokenWriter formatter     = new ParameterHighlightingOutputFormatter(stringBuilder, highlightedParameterIndex);

            ambience.ConvertSymbol(Method, formatter, FormattingOptionsFactory.CreateSharpDevelop());
            var documentation = XmlDocumentationElement.Get(Method);

            ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;

            var inlineBuilder = new HighlightedInlineBuilder(stringBuilder.ToString());

            header.Inlines.Clear();
            header.Inlines.AddRange(inlineBuilder.CreateRuns());
        }
Exemple #11
0
        public void InheritedDocumentation()
        {
            Init(@"using System;
class Derived : Base {
	/// <summary>Overridden summary</summary><inheritdoc/>
	public override void Method();
}
class Base {
	/// <summary>Base summary</summary><remarks>Base remarks</remarks>
	public virtual void Method();
}
");
            var element = XmlDocumentationElement.Get(typeDefinition.Methods.Single(m => m.Name == "Method"));

            Assert.AreEqual(2, element.Children.Count());
            Assert.AreEqual("summary", element.Children[0].Name);
            Assert.AreEqual("remarks", element.Children[1].Name);
            Assert.AreEqual("Overridden summary", element.Children[0].TextContent);
            Assert.AreEqual("Base remarks", element.Children[1].TextContent);
        }
Exemple #12
0
        public SDLanguageItemCollection <SDDocumentation> ParseDocumentation(IEntity entity)
        {
            var docDic = new SDLanguageItemCollection <SDDocumentation>();

            try
            {
                if (entity != null)
                {
                    var xmlDoc = XmlDocumentationElement.Get(entity);

                    if (xmlDoc != null)
                    {
                        foreach (XmlDocumentationElement child in xmlDoc.Children)
                        {
                            if (CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(c => c.TwoLetterISOLanguageName == child.Name.ToLower()) || child.Name.ToLower() == "default")
                            {
                                // TODO
                                //_sdRepository.AddDocumentationLanguage(child.Name.ToLower());
                                var languageDoc = ParseDocumentation(child.Children);
                                docDic.Add(child.Name.ToLower(), languageDoc);
                            }
                        }

                        //Es wurde keine Sprachunterstützung in der Doku genutzt.
                        //Deswegen wird die Doku einfach als "default" geladen.
                        if (docDic.Count == 0)
                        {
                            var defaultDoc = ParseDocumentation(xmlDoc.Children);
                            docDic.Add("default", defaultDoc);
                        }
                    }
                }
            }
            catch (NullReferenceException ex)
            {
                Trace.TraceError(ex.ToString());
            }

            return(docDic);
        }
        public void AddDocumentationElement(XmlDocumentationElement element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
            if (element.IsTextNode)
            {
                AddText(element.TextContent);
                return;
            }
            switch (element.Name)
            {
            case "b":
                AddSpan(new Bold(), element.Children);
                break;

            case "i":
                AddSpan(new Italic(), element.Children);
                break;

            case "c":
                AddSpan(new Span {
                    FontFamily = GetCodeFont()
                }, element.Children);
                break;

            case "code":
                AddCodeBlock(element.TextContent);
                break;

            case "example":
                if (ShowExample)
                {
                    AddSection("Example: ", element.Children);
                }
                break;

            case "exception":
                if (ShowExceptions)
                {
                    AddException(element.ReferencedEntity, element.Children);
                }
                break;

            case "list":
                AddList(element.GetAttribute("type"), element.Children);
                break;

            //case "note":
            //	throw new NotImplementedException();
            case "para":
                AddParagraph(new Paragraph {
                    Margin = new Thickness(0, 5, 0, 5)
                }, element.Children);
                break;

            case "param":
                if (ShowAllParameters || (ParameterName != null && ParameterName == element.GetAttribute("name")))
                {
                    AddParam(element.GetAttribute("name"), element.Children);
                }
                break;

            case "paramref":
                AddParamRef(element.GetAttribute("name"));
                break;

            case "permission":
                if (ShowPermissions)
                {
                    AddPermission(element.ReferencedEntity, element.Children);
                }
                break;

            case "preliminary":
                if (ShowPreliminary)
                {
                    AddPreliminary(element.Children);
                }
                break;

            case "remarks":
                if (ShowRemarks)
                {
                    AddSection("Remarks: ", element.Children);
                }
                break;

            case "returns":
                if (ShowReturns)
                {
                    AddSection("Returns: ", element.Children);
                }
                break;

            case "see":
                AddSee(element);
                break;

            case "seealso":
                if (inlineCollection != null)
                {
                    AddSee(element);
                }
                else if (ShowSeeAlso)
                {
                    AddSection(new Run("See also: "), () => AddSee(element));
                }
                break;

            case "summary":
                if (ShowSummary)
                {
                    AddSection("Summary: ", element.Children);
                }
                break;

            case "threadsafety":
                if (ShowThreadSafety)
                {
                    AddThreadSafety(ParseBool(element.GetAttribute("static")), ParseBool(element.GetAttribute("instance")), element.Children);
                }
                break;

            case "typeparam":
                if (ShowTypeParameters)
                {
                    AddSection("Type parameter " + element.GetAttribute("name") + ": ", element.Children);
                }
                break;

            case "typeparamref":
                AddText(element.GetAttribute("name"));
                break;

            case "value":
                if (ShowValue)
                {
                    AddSection("Value: ", element.Children);
                }
                break;

            case "exclude":
            case "filterpriority":
            case "overloads":
                // ignore children
                break;

            case "br":
                AddLineBreak();
                break;

            default:
                foreach (var child in element.Children)
                {
                    AddDocumentationElement(child);
                }
                break;
            }
        }