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);
}
