public void PlainChunkIsNotAnnotated()
        {
            var ch = new AnnotatedCodeChunk <ICodeDetails> {
                TextValue = "just text"
            };

            var chHtmlized = new CodeChunkHtmlizer().HtmlizeChunkText(1, ch);

            Assert.Equal("just text", chHtmlized);
        }
        public void TypesAreMatchedAndExtendedDescriptionIsProvided()
        {
            var enh            = new XmlDocEnhancer(new[] { @"<?xml version=""1.0""?>
<doc>
    <assembly>
        <name>Castle.Windsor</name>
    </assembly>
    <members>
        <member name=""T:Castle.MicroKernel.Facilities.AbstractFacility"">
            <summary>
              Base class for facilities.
            </summary>
        </member>
        <member name=""T:Castle.MicroKernel.IFacility"">
            <summary>
              Unit of extension. A facility should use 
              the extension points offered by the kernel
              to augment its functionality.
            </summary>
        </member>
        <member name=""M:Castle.MicroKernel.IFacility.Init(Castle.MicroKernel.IKernel,Castle.Core.Configuration.IConfiguration)"">
            <summary>
            </summary>
            <param name = ""kernel""></param>
            <param name = ""facilityConfig""></param>
        </member>
    </members>
</doc>
" });
            var chunkToEnhance = new AnnotatedCodeChunk <TypeDetails>
            {
                CodeType     = Common.CodeType.Type,
                LineNumber   = 1,
                TextValue    = "interface Castle.MicroKernel.IFacility",
                TooltipValue = "IFacility",
                Details      = new TypeDetails {
                    FullName = "Castle.MicroKernel.IFacility"
                }
            };
            var enhancedChunk = enh.EnhanceChunk(chunkToEnhance);

            Assert.Equal(enhancedChunk.ExtendedDescription, "Unit of extension. A facility should use the extension points offered by the kernel to augment its functionality.");
        }
        public override void VisitTrivia(SyntaxTrivia trivia)
        {
            var atch = new AnnotatedCodeChunk <ICodeDetails> {
                TextValue = trivia.ToString()
            };

            var triviaKind = trivia.Kind();

            if (triviaKind == SyntaxKind.SingleLineCommentTrivia ||
                triviaKind == SyntaxKind.MultiLineCommentTrivia ||
                triviaKind == SyntaxKind.XmlComment)
            {
                atch.CodeType = CodeType.Comment;
            }

            AddItcAction(trivia.SpanStart, atch);

            base.VisitTrivia(trivia);
        }
        public override void VisitToken(SyntaxToken token)
        {
            IAnnotatedCodeChunk itc = new AnnotatedCodeChunk <ICodeDetails> {
                TextValue = token.Text
            };

            var parentNode = token.Parent;

            if (token.IsKind(SyntaxKind.IdentifierToken))
            {
                switch (parentNode)
                {
                case IdentifierNameSyntax identifierNameSyntaxNode:     // var, or variable mention
                    var symbol = SemanticModel.GetSymbolInfo(identifierNameSyntaxNode).Symbol;

                    switch (symbol)
                    {
                    case INamedTypeSymbol namedTypeSymbol:         // var, or variable mention
                        if (parentNode.ToString() == "var")
                        {
                            itc.CodeType = CodeType.Keyword;
                        }
                        else
                        {
                            itc = new AnnotatedCodeChunk <TypeDetails>
                            {
                                CodeType  = CodeType.Type,
                                TextValue = token.Text,
                                Details   = new TypeDetails
                                {
                                    FullName = namedTypeSymbol.ToDisplayString()
                                }
                            };
                        }
                        itc.TooltipValue = GetTooltipForType(namedTypeSymbol);

                        break;

                    case IFieldSymbol fieldSymbol:         // variable mention
                        itc.CodeType     = CodeType.Variable;
                        itc.TooltipValue = GetTooltipForType(fieldSymbol.Type);
                        break;

                    case IMethodSymbol methodSymbol:         // method call
                        itc = new AnnotatedCodeChunk <MethodDetails>
                        {
                            CodeType     = CodeType.Method,
                            TextValue    = token.Text,
                            TooltipValue = GetTooltipForMethod(methodSymbol),
                            Details      = GetMethodDetails(methodSymbol)
                        };
                        break;

                    case INamespaceSymbol namespaceSymbol:
                        itc.CodeType     = CodeType.Namespace;
                        itc.TooltipValue = GetTooltipForNamespace(namespaceSymbol);
                        break;

                    case IPropertySymbol propertySymbol:
                        itc.CodeType     = CodeType.Property;
                        itc.TooltipValue = GetTooltipForProperty(propertySymbol);
                        break;
                    }
                    break;

                case VariableDeclaratorSyntax variableDeclaratorNode:     // variable name declaration
                    var declaredSymbol = SemanticModel.GetDeclaredSymbol(parentNode);
                    var typeSymbol     = declaredSymbol as IFieldSymbol;
                    itc.CodeType     = CodeType.Variable;
                    itc.TooltipValue = GetTooltipForType(typeSymbol?.Type);
                    break;

                case GenericNameSyntax genericNameNode:
                    var symbolInfo = SemanticModel.GetSymbolInfo(parentNode).Symbol;

                    switch (symbolInfo)
                    {
                    case INamedTypeSymbol namedTypeSymbolInfo:
                        itc = new AnnotatedCodeChunk <TypeDetails>
                        {
                            CodeType  = CodeType.Type,
                            TextValue = token.Text,
                            Details   = new TypeDetails
                            {
                                FullName = namedTypeSymbolInfo.ToDisplayString()
                            },
                            TooltipValue = GetTooltipForType(namedTypeSymbolInfo)
                        };
                        break;

                    case IMethodSymbol methodSymbol:         // method call
                        itc = new AnnotatedCodeChunk <MethodDetails>
                        {
                            CodeType     = CodeType.Method,
                            TextValue    = token.Text,
                            TooltipValue = GetTooltipForMethod(methodSymbol),
                            Details      = GetMethodDetails(methodSymbol)
                        };
                        break;
                    }

                    break;
                }
            }
            else if (parentNode is PredefinedTypeSyntax) // "int"
            {
                var type = SemanticModel.GetTypeInfo(parentNode).Type;
                itc.CodeType     = CodeType.Keyword;
                itc.TooltipValue = GetTooltipForType(type);
            }

            if (token.IsKeyword())
            {
                itc.CodeType = CodeType.Keyword;
            }

            AddItcAction(token.SpanStart, itc);

            base.VisitToken(token);
        }