public void DecorateCodeBuilder_DesignTimeRazorPathNormalizer_NormalizesChunkInheritanceUtilityPaths(
string rootPrefix)
{
// Arrange
var rootedAppPath = $"{rootPrefix}SomeComputer/Location/Project/";
var rootedFilePath = $"{rootPrefix}SomeComputer/Location/Project/src/file.cshtml";
var host = new MvcRazorHost(
codeTreeCache: null,
pathNormalizer: new DesignTimeRazorPathNormalizer(rootedAppPath));
var chunkInheritanceUtility = new PathValidatingChunkInheritanceUtility(host);
var codeBuilderContext = new CodeBuilderContext(
new CodeGeneratorContext(
host,
host.DefaultClassName,
host.DefaultNamespace,
rootedFilePath,
shouldGenerateLinePragmas: true),
new ParserErrorSink());
var codeBuilder = new CSharpCodeBuilder(codeBuilderContext);
host.ChunkInheritanceUtility = chunkInheritanceUtility;
// Act
host.DecorateCodeBuilder(codeBuilder, codeBuilderContext);
// Assert
Assert.Equal("src/file.cshtml", chunkInheritanceUtility.InheritedCodeTreePagePath, StringComparer.Ordinal);
}
public void RenderAttributeValue_RendersModelExpressionsCorrectly(string modelExpressionType,
string propertyType,
string expectedValue)
{
// Arrange
var renderer = new MvcTagHelperAttributeValueCodeRenderer(
new GeneratedTagHelperAttributeContext
{
ModelExpressionTypeName = modelExpressionType,
CreateModelExpressionMethodName = "SomeMethod"
});
var attributeDescriptor = new TagHelperAttributeDescriptor("MyAttribute", "SomeProperty", propertyType);
var writer = new CSharpCodeWriter();
var generatorContext = new CodeGeneratorContext(host: null,
className: string.Empty,
rootNamespace: string.Empty,
sourceFile: string.Empty,
shouldGenerateLinePragmas: true);
var errorSink = new ParserErrorSink();
var context = new CodeBuilderContext(generatorContext, errorSink);
// Act
renderer.RenderAttributeValue(attributeDescriptor, writer, context,
(codeWriter) =>
{
codeWriter.Write("MyValue");
},
complexValue: false);
// Assert
Assert.Equal(expectedValue, writer.GenerateCode());
}
public void CodeTreeWithUsings()
{
var syntaxTreeNode = new Mock<Span>(new SpanBuilder());
var language = new CSharpRazorCodeLanguage();
var host = new CodeGenTestHost(language);
var codeBuilderContext = new CodeBuilderContext(
host,
"TestClass",
"TestNamespace",
"Foo.cs",
shouldGenerateLinePragmas: false,
errorSink: new ErrorSink());
codeBuilderContext.CodeTreeBuilder.AddUsingChunk("FakeNamespace1", syntaxTreeNode.Object);
codeBuilderContext.CodeTreeBuilder.AddUsingChunk("FakeNamespace2.SubNamespace", syntaxTreeNode.Object);
var codeBuilder = new CodeGenTestCodeBuilder(codeBuilderContext);
// Act
var result = codeBuilder.Build();
BaselineWriter.WriteBaseline(
@"test\Microsoft.AspNet.Razor.Test\TestFiles\CodeGenerator\CS\Output\CSharpCodeBuilder.cs",
result.Code);
var expectedOutput = TestFile.Create("TestFiles/CodeGenerator/CS/Output/CSharpCodeBuilder.cs").ReadAllText();
// Assert
Assert.Equal(expectedOutput, result.Code);
}
protected override CSharpCodeVisitor CreateCSharpCodeVisitor(
CSharpCodeWriter writer,
CodeBuilderContext context)
{
var bodyVisitor = base.CreateCSharpCodeVisitor(writer, context);
bodyVisitor.TagHelperRenderer.AttributeValueCodeRenderer = new CustomTagHelperAttributeCodeRenderer();
return bodyVisitor;
}
public override CodeBuilder DecorateCodeBuilder(CodeBuilder incomingBuilder, CodeBuilderContext context)
{
if (incomingBuilder is CodeGenTestCodeBuilder)
{
return incomingBuilder;
}
else
{
return new CodeGenTestCodeBuilder(context);
}
}
private static Mock<ChunkVisitor<CodeWriter>> CreateVisitor()
{
var codeBuilderContext = new CodeBuilderContext(
new RazorEngineHost(new CSharpRazorCodeLanguage()),
"myclass",
"myns",
string.Empty,
shouldGenerateLinePragmas: false,
errorSink: new ParserErrorSink());
var writer = Mock.Of<CodeWriter>();
return new Mock<ChunkVisitor<CodeWriter>>(writer, codeBuilderContext);
}
public void CreateCodeBuilder_ReturnsNewCSharpCodeBuilder()
{
// Arrange
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language);
var codeBuilderContext = new CodeBuilderContext(
host,
"myclass",
"myns",
string.Empty,
shouldGenerateLinePragmas: false,
errorSink: new ErrorSink());
// Act
var generator = language.CreateCodeBuilder(codeBuilderContext);
// Assert
Assert.IsType<CSharpCodeBuilder>(generator);
}
public abstract CodeBuilder CreateCodeBuilder(CodeBuilderContext codeGeneratorContext);
public TrackingUniqueIdsTagHelperCodeRenderer(
IChunkVisitor bodyVisitor,
CSharpCodeWriter writer,
CodeBuilderContext context)
: base(bodyVisitor, writer, context)
{
}
/// <summary>
/// Gets an instance of the code builder and is provided an opportunity to decorate or replace it
/// </summary>
/// <param name="incomingBuilder">The code builder</param>
/// <returns>Either the same code builder, after modifications, or a different code builder.</returns>
public virtual CodeBuilder DecorateCodeBuilder(CodeBuilder incomingBuilder, CodeBuilderContext context)
{
if (incomingBuilder == null)
{
throw new ArgumentNullException("incomingBuilder");
}
return incomingBuilder;
}
public override void RenderAttributeValue(
TagHelperAttributeDescriptor attributeInfo,
CSharpCodeWriter writer,
CodeBuilderContext context,
Action<CSharpCodeWriter> renderAttributeValue,
bool complexValue)
{
writer.Write("**From custom attribute code renderer**: ");
base.RenderAttributeValue(attributeInfo, writer, context, renderAttributeValue, complexValue);
}
public TestCSharpCodeBuilder(CodeBuilderContext context,
string defaultModel,
string activateAttribute,
GeneratedTagHelperAttributeContext tagHelperAttributeContext)
: base(context, defaultModel, activateAttribute, tagHelperAttributeContext)
{
_tagHelperAttributeContext = tagHelperAttributeContext;
}
protected internal virtual CodeBuilder CreateCodeBuilder(CodeBuilderContext context)
{
return Host.DecorateCodeBuilder(Host.CodeLanguage.CreateCodeBuilder(context),
context);
}
public override CodeBuilder DecorateCodeBuilder(CodeBuilder incomingBuilder, CodeBuilderContext context)
{
return new AttributeCodeGeneratorReplacingCodeBuilder(context);
}
protected internal virtual GeneratorResults GenerateCodeCore(ITextDocument input,
string className,
string rootNamespace,
string sourceFileName,
string checksum,
CancellationToken? cancelToken)
{
className = (className ?? Host.DefaultClassName) ?? DefaultClassName;
rootNamespace = (rootNamespace ?? Host.DefaultNamespace) ?? DefaultNamespace;
// Run the parser
var parser = CreateParser(sourceFileName);
Debug.Assert(parser != null);
var results = parser.Parse(input);
// Generate code
var generator = CreateCodeGenerator(className, rootNamespace, sourceFileName);
generator.DesignTimeMode = Host.DesignTimeMode;
generator.Visit(results);
var codeBuilderContext = new CodeBuilderContext(generator.Context, results.ErrorSink);
codeBuilderContext.Checksum = checksum;
var builder = CreateCodeBuilder(codeBuilderContext);
var builderResult = builder.Build();
// Collect results and return
return new GeneratorResults(results, builderResult, codeBuilderContext.CodeTreeBuilder.CodeTree);
}
public override CodeBuilder CreateCodeBuilder(CodeBuilderContext context)
{
return new CSharpCodeBuilder(context);
}
public TestCSharpCodeBuilder(CodeBuilderContext context)
: base(context)
{
}
protected internal override CodeBuilder CreateCodeBuilder(CodeBuilderContext context)
{
return Host.DecorateCodeBuilder(new TestCSharpCodeBuilder(context), context);
}
protected override CSharpCodeVisitor CreateCSharpCodeVisitor(CSharpCodeWriter writer, CodeBuilderContext context)
{
var visitor = base.CreateCSharpCodeVisitor(writer, context);
visitor.TagHelperRenderer = new NoUniqueIdsTagHelperCodeRenderer(visitor, writer, context);
return visitor;
}
public AttributeCodeGeneratorReplacingCodeBuilder(CodeBuilderContext context)
: base(context)
{
}
public CodeGenTestCodeBuilder(CodeBuilderContext context)
: base(context)
{
}
/// <summary>
/// Gets an instance of the code builder and is provided an opportunity to decorate or replace it
/// </summary>
/// <param name="incomingBuilder">The code builder</param>
/// <returns>Either the same code builder, after modifications, or a different code builder.</returns>
public virtual CodeBuilder DecorateCodeBuilder(
[NotNull] CodeBuilder incomingBuilder,
CodeBuilderContext context)
{
return incomingBuilder;
}
public override CodeBuilder DecorateCodeBuilder(CodeBuilder incomingBuilder, CodeBuilderContext context)
{
base.DecorateCodeBuilder(incomingBuilder, context);
return new TestCSharpCodeBuilder(context,
DefaultModel,
ActivateAttribute,
new GeneratedTagHelperAttributeContext
{
ModelExpressionTypeName = ModelExpressionType,
CreateModelExpressionMethodName = CreateModelExpressionMethod
});
}