public override void VisitDirective(DirectiveIntermediateNode node) { if (node.Directive == Directive) { ModelDirectives.Add(node); } }
public override void VisitDirective(DirectiveIntermediateNode node) { if (node.Directive == ComponentInjectDirective.Directive) { Directives.Add(node); } }
public void Execute_AddsRazorPagettribute_ToPage() { // Arrange var expectedAttribute = "[assembly:global::Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.RazorPageAttribute(@\"/Views/Index.cshtml\", typeof(SomeNamespace.SomeName), null)]"; var irDocument = new DocumentIntermediateNode { DocumentKind = RazorPageDocumentClassifierPass.RazorPageDocumentKind, }; var builder = IntermediateNodeBuilder.Create(irDocument); var pageDirective = new DirectiveIntermediateNode { Directive = PageDirective.Directive, }; builder.Add(pageDirective); var @namespace = new NamespaceDeclarationIntermediateNode { Content = "SomeNamespace", Annotations = { [CommonAnnotations.PrimaryNamespace] = CommonAnnotations.PrimaryNamespace }, }; builder.Push(@namespace); var @class = new ClassDeclarationIntermediateNode { ClassName = "SomeName", Annotations = { [CommonAnnotations.PrimaryClass] = CommonAnnotations.PrimaryClass, }, }; builder.Add(@class); var pass = new AssemblyAttributeInjectionPass { Engine = RazorEngine.Create(), }; var source = TestRazorSourceDocument.Create("test", new RazorSourceDocumentProperties(filePath: null, relativePath: "/Views/Index.cshtml")); var document = RazorCodeDocument.Create(source); // Act pass.Execute(document, irDocument); // Assert Assert.Collection(irDocument.Children, node => Assert.Same(pageDirective, node), node => { var csharpCode = Assert.IsType <CSharpCodeIntermediateNode>(node); var token = Assert.IsType <IntermediateToken>(Assert.Single(csharpCode.Children)); Assert.Equal(TokenKind.CSharp, token.Kind); Assert.Equal(expectedAttribute, token.Content); }, node => Assert.Same(@namespace, node)); }
public override void VisitDirectiveBlock(DirectiveChunkGenerator chunkGenerator, Block block) { IntermediateNode directiveNode; if (IsMalformed(chunkGenerator.Diagnostics)) { directiveNode = new MalformedDirectiveIntermediateNode() { DirectiveName = chunkGenerator.Descriptor.Directive, Directive = chunkGenerator.Descriptor, Source = BuildSourceSpanFromNode(block), }; } else { directiveNode = new DirectiveIntermediateNode() { DirectiveName = chunkGenerator.Descriptor.Directive, Directive = chunkGenerator.Descriptor, Source = BuildSourceSpanFromNode(block), }; } for (var i = 0; i < chunkGenerator.Diagnostics.Count; i++) { directiveNode.Diagnostics.Add(chunkGenerator.Diagnostics[i]); } _builder.Push(directiveNode); VisitDefault(block); _builder.Pop(); }
public override void VisitDirective(DirectiveIntermediateNode node) { if (node.Directive == Directive) { DirectiveNode = node; DirectiveTokens = node.Tokens; } }
public override void VisitDirective(DirectiveIntermediateNode node) { if (node.Directive == Directive) { LastNamespaceDirective = node; } base.VisitDirective(node); }
public override void VisitDirective(DirectiveIntermediateNode node) { if (_directive == node.Directive) { Directives.Add(new IntermediateNodeReference(Parent, node)); } base.VisitDirective(node); }
public void FindDirectiveReferences_FindsMatchingDirectives() { // Arrange var directive = DirectiveDescriptor.CreateSingleLineDirective("test"); var directive2 = DirectiveDescriptor.CreateSingleLineDirective("test"); var document = new DocumentIntermediateNode(); var @namespace = new NamespaceDeclarationIntermediateNode(); var builder = IntermediateNodeBuilder.Create(document); builder.Push(@namespace); var match1 = new DirectiveIntermediateNode() { Directive = directive, }; builder.Add(match1); var nonMatch = new DirectiveIntermediateNode() { Directive = directive2, }; builder.Add(nonMatch); var match2 = new DirectiveIntermediateNode() { Directive = directive, }; builder.Add(match2); // Act var results = document.FindDirectiveReferences(directive); // Assert Assert.Collection( results, r => { Assert.Same(@namespace, r.Parent); Assert.Same(match1, r.Node); }, r => { Assert.Same(@namespace, r.Parent); Assert.Same(match2, r.Node); }); }
// internal for testing. // // This code does a best-effort attempt to compute a namespace 'suffix' - the path difference between // where the @namespace directive appears and where the current document is on disk. // // In the event that these two source either don't have FileNames set or don't follow a coherent hierarchy, // we will just use the namespace verbatim. internal static bool TryComputeNamespace(string source, DirectiveIntermediateNode directive, out string @namespace) { var directiveSource = NormalizeDirectory(directive.Source?.FilePath); var baseNamespace = directive.Tokens.FirstOrDefault()?.Content; if (string.IsNullOrEmpty(baseNamespace)) { // The namespace directive was incomplete. @namespace = string.Empty; return(false); } if (string.IsNullOrEmpty(source) || directiveSource == null) { // No sources, can't compute a suffix. @namespace = baseNamespace; return(false); } // We're specifically using OrdinalIgnoreCase here because Razor treats all paths as case-insensitive. if (!source.StartsWith(directiveSource, StringComparison.OrdinalIgnoreCase) || source.Length <= directiveSource.Length) { // The imports are not from the directory hierarchy, can't compute a suffix. @namespace = baseNamespace; return(false); } // OK so that this point we know that the 'imports' file containing this directive is in the directory // hierarchy of this soure file. This is the case where we can append a suffix to the baseNamespace. // // Everything so far has just been defensiveness on our part. var builder = new StringBuilder(baseNamespace); var segments = source.Substring(directiveSource.Length).Split(Separators); // Skip the last segment because it's the FileName. for (var i = 0; i < segments.Length - 1; i++) { builder.Append('.'); builder.Append(CSharpIdentifier.SanitizeClassName(segments[i])); } @namespace = builder.ToString(); return(true); }
public void GetNamespace_IncompleteDirective_UsesEmptyNamespace() { // Arrange var source = "c:\\foo\\bar\\bleh.cshtml"; var imports = "c:\\foo\\baz\\bleh.cshtml"; var node = new DirectiveIntermediateNode() { Directive = NamespaceDirective.Directive, Source = new SourceSpan(imports, 0, 0, 0, 0), }; // Act var @namespace = NamespaceDirective.GetNamespace(source, node); // Assert Assert.Equal(string.Empty, @namespace); }
public override void VisitRazorDirective(RazorDirectiveSyntax node) { IntermediateNode directiveNode; var descriptor = node.DirectiveDescriptor; if (descriptor != null) { var diagnostics = node.GetDiagnostics(); // This is an extensible directive. if (IsMalformed(diagnostics)) { directiveNode = new MalformedDirectiveIntermediateNode() { DirectiveName = descriptor.Directive, Directive = descriptor, Source = BuildSourceSpanFromNode(node), }; } else { directiveNode = new DirectiveIntermediateNode() { DirectiveName = descriptor.Directive, Directive = descriptor, Source = BuildSourceSpanFromNode(node), }; } for (var i = 0; i < diagnostics.Length; i++) { directiveNode.Diagnostics.Add(diagnostics[i]); } _builder.Push(directiveNode); } Visit(node.Body); if (descriptor != null) { _builder.Pop(); } }
public void GetNamespace_ForRelatedFiles_ComputesNamespaceWithSuffix(string source, string imports, string expected) { // Arrange var node = new DirectiveIntermediateNode() { Directive = NamespaceDirective.Directive, Source = new SourceSpan(imports, 0, 0, 0, 0), }; node.Children.Add(new DirectiveTokenIntermediateNode() { Content = "Base" }); // Act var @namespace = NamespaceDirective.GetNamespace(source, node); // Assert Assert.Equal(expected, @namespace); }
public void GetNamespace_ForNonRelatedFiles_UsesNamespaceVerbatim(string source, string imports) { // Arrange var node = new DirectiveIntermediateNode() { Directive = NamespaceDirective.Directive, Source = new SourceSpan(imports, 0, 0, 0, 0), }; node.Children.Add(new DirectiveTokenIntermediateNode() { Content = "Base" }); // Act var @namespace = NamespaceDirective.GetNamespace(source, node); // Assert Assert.Equal("Base", @namespace); }
public override void VisitTagHelperPrefixDirectiveSpan(TagHelperPrefixDirectiveChunkGenerator chunkGenerator, Span span) { IntermediateNode directiveNode; if (IsMalformed(chunkGenerator.Diagnostics)) { directiveNode = new MalformedDirectiveIntermediateNode() { DirectiveName = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor.Directive, Directive = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor, Source = BuildSourceSpanFromNode(span), }; } else { directiveNode = new DirectiveIntermediateNode() { DirectiveName = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor.Directive, Directive = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor, Source = BuildSourceSpanFromNode(span), }; } for (var i = 0; i < chunkGenerator.Diagnostics.Count; i++) { directiveNode.Diagnostics.Add(chunkGenerator.Diagnostics[i]); } _builder.Push(directiveNode); _builder.Add(new DirectiveTokenIntermediateNode() { Content = chunkGenerator.Prefix, DirectiveToken = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor.Tokens.First(), Source = BuildSourceSpanFromNode(span), }); _builder.Pop(); }
public void GetNamespace_EmptyDirective_UsesEmptyNamespace() { // Arrange var source = "c:\\foo\\bar\\bleh.cshtml"; var imports = "c:\\foo\\baz\\bleh.cshtml"; var node = new DirectiveIntermediateNode() { Directive = NamespaceDirective.Directive, Source = new SourceSpan(imports, 0, 0, 0, 0), }; node.Children.Add(new DirectiveTokenIntermediateNode() { Content = string.Empty }); // Act var @namespace = NamespaceDirective.GetNamespace(source, node); // Assert Assert.Equal(string.Empty, @namespace); }
public virtual void VisitDirective(DirectiveIntermediateNode node) { VisitDefault(node); }
public override void VisitDirective(DirectiveIntermediateNode node) { WriteContentNode(node, node.DirectiveName); }
public override void VisitDirective(DirectiveIntermediateNode node) { DirectiveNodes.Add(new IntermediateNodeReference(Parent, node)); }
public override void VisitCSharpStatementLiteral(CSharpStatementLiteralSyntax node) { var context = node.GetSpanContext(); if (context == null) { base.VisitCSharpStatementLiteral(node); return; } else if (context.ChunkGenerator is DirectiveTokenChunkGenerator tokenChunkGenerator) { _builder.Add(new DirectiveTokenIntermediateNode() { Content = node.GetContent(), DirectiveToken = tokenChunkGenerator.Descriptor, Source = BuildSourceSpanFromNode(node), }); } else if (context.ChunkGenerator is AddImportChunkGenerator importChunkGenerator) { var namespaceImport = importChunkGenerator.Namespace.Trim(); var namespaceSpan = BuildSourceSpanFromNode(node); _usings.Add(new UsingReference(namespaceImport, namespaceSpan)); } else if (context.ChunkGenerator is AddTagHelperChunkGenerator addTagHelperChunkGenerator) { IntermediateNode directiveNode; if (IsMalformed(addTagHelperChunkGenerator.Diagnostics)) { directiveNode = new MalformedDirectiveIntermediateNode() { DirectiveName = CSharpCodeParser.AddTagHelperDirectiveDescriptor.Directive, Directive = CSharpCodeParser.AddTagHelperDirectiveDescriptor, Source = BuildSourceSpanFromNode(node), }; } else { directiveNode = new DirectiveIntermediateNode() { DirectiveName = CSharpCodeParser.AddTagHelperDirectiveDescriptor.Directive, Directive = CSharpCodeParser.AddTagHelperDirectiveDescriptor, Source = BuildSourceSpanFromNode(node), }; } for (var i = 0; i < addTagHelperChunkGenerator.Diagnostics.Count; i++) { directiveNode.Diagnostics.Add(addTagHelperChunkGenerator.Diagnostics[i]); } _builder.Push(directiveNode); _builder.Add(new DirectiveTokenIntermediateNode() { Content = addTagHelperChunkGenerator.LookupText, DirectiveToken = CSharpCodeParser.AddTagHelperDirectiveDescriptor.Tokens.First(), Source = BuildSourceSpanFromNode(node), }); _builder.Pop(); } else if (context.ChunkGenerator is RemoveTagHelperChunkGenerator removeTagHelperChunkGenerator) { IntermediateNode directiveNode; if (IsMalformed(removeTagHelperChunkGenerator.Diagnostics)) { directiveNode = new MalformedDirectiveIntermediateNode() { DirectiveName = CSharpCodeParser.RemoveTagHelperDirectiveDescriptor.Directive, Directive = CSharpCodeParser.RemoveTagHelperDirectiveDescriptor, Source = BuildSourceSpanFromNode(node), }; } else { directiveNode = new DirectiveIntermediateNode() { DirectiveName = CSharpCodeParser.RemoveTagHelperDirectiveDescriptor.Directive, Directive = CSharpCodeParser.RemoveTagHelperDirectiveDescriptor, Source = BuildSourceSpanFromNode(node), }; } for (var i = 0; i < removeTagHelperChunkGenerator.Diagnostics.Count; i++) { directiveNode.Diagnostics.Add(removeTagHelperChunkGenerator.Diagnostics[i]); } _builder.Push(directiveNode); _builder.Add(new DirectiveTokenIntermediateNode() { Content = removeTagHelperChunkGenerator.LookupText, DirectiveToken = CSharpCodeParser.RemoveTagHelperDirectiveDescriptor.Tokens.First(), Source = BuildSourceSpanFromNode(node), }); _builder.Pop(); } else if (context.ChunkGenerator is TagHelperPrefixDirectiveChunkGenerator tagHelperPrefixChunkGenerator) { IntermediateNode directiveNode; if (IsMalformed(tagHelperPrefixChunkGenerator.Diagnostics)) { directiveNode = new MalformedDirectiveIntermediateNode() { DirectiveName = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor.Directive, Directive = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor, Source = BuildSourceSpanFromNode(node), }; } else { directiveNode = new DirectiveIntermediateNode() { DirectiveName = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor.Directive, Directive = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor, Source = BuildSourceSpanFromNode(node), }; } for (var i = 0; i < tagHelperPrefixChunkGenerator.Diagnostics.Count; i++) { directiveNode.Diagnostics.Add(tagHelperPrefixChunkGenerator.Diagnostics[i]); } _builder.Push(directiveNode); _builder.Add(new DirectiveTokenIntermediateNode() { Content = tagHelperPrefixChunkGenerator.Prefix, DirectiveToken = CSharpCodeParser.TagHelperPrefixDirectiveDescriptor.Tokens.First(), Source = BuildSourceSpanFromNode(node), }); _builder.Pop(); } base.VisitCSharpStatementLiteral(node); }