private static RazorTemplateEngine CreateTemplateEngine(
string path = "C:\\This\\Path\\Is\\Just\\For\\Line\\Pragmas.cshtml",
IEnumerable <TagHelperDescriptor> tagHelpers = null)
{
var engine = RazorEngine.CreateDesignTime(builder =>
{
RazorExtensions.Register(builder);
if (tagHelpers != null)
{
builder.AddTagHelpers(tagHelpers);
}
});
// GetImports on RazorTemplateEngine will at least check that the item exists, so we need to pretend
// that it does.
var items = new List <RazorProjectItem>();
items.Add(new TestRazorProjectItem(path));
var project = new TestRazorProject(items);
var templateEngine = new RazorTemplateEngine(engine, project);
templateEngine.Options.DefaultImports = RazorSourceDocument.Create("@addTagHelper *, Test", "_TestImports.cshtml");
return(templateEngine);
}
private static RazorTemplateEngineFactoryService CreateTemplateEngineFactory(
string path = TestLinePragmaFileName,
IEnumerable <TagHelperDescriptor> tagHelpers = null)
{
var engine = RazorEngine.CreateDesignTime(builder =>
{
RazorExtensions.Register(builder);
if (tagHelpers != null)
{
builder.AddTagHelpers(tagHelpers);
}
});
// GetImports on RazorTemplateEngine will at least check that the item exists, so we need to pretend
// that it does.
var items = new List <RazorProjectItem>();
items.Add(new TestRazorProjectItem(path));
var project = new TestRazorProject(items);
var templateEngine = new RazorTemplateEngine(engine, project);
templateEngine.Options.DefaultImports = RazorSourceDocument.Create("@addTagHelper *, Test", "_TestImports.cshtml");
var templateEngineFactory = Mock.Of <RazorTemplateEngineFactoryService>(
service => service.Create(It.IsAny <string>(), It.IsAny <Action <IRazorEngineBuilder> >()) == templateEngine);
return(templateEngineFactory);
}
private void RunDesignTimeTagHelpersTest(IEnumerable <TagHelperDescriptor> descriptors)
{
// Arrange
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.Features.Add(new ApiSetsIRTestAdapter());
builder.AddTagHelpers(descriptors);
// Some of these tests use templates
builder.AddTargetExtension(new TemplateTargetExtension());
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
var document = CreateCodeDocument();
// Act
engine.Process(document);
// Assert
AssertDocumentNodeMatchesBaseline(document.GetDocumentIntermediateNode());
AssertCSharpDocumentMatchesBaseline(document.GetCSharpDocument());
AssertSourceMappingsMatchBaseline(document);
}
private void DesignTimeTest()
{
// Arrange
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.ConfigureDocumentClassifier();
// Some of these tests use templates
builder.AddTargetExtension(new TemplateTargetExtension());
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
var document = CreateCodeDocument();
// Act
engine.Process(document);
// Assert
AssertDocumentNodeMatchesBaseline(document.GetDocumentIntermediateNode());
AssertCSharpDocumentMatchesBaseline(document.GetCSharpDocument());
AssertSourceMappingsMatchBaseline(document);
}
public void CreateDesignTime_Lambda_AddsFeaturesAndPhases()
{
// Arrange
IRazorEngineFeature[] features = null;
IRazorEnginePhase[] phases = null;
// Act
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.Features.Clear();
builder.Phases.Clear();
builder.Features.Add(Mock.Of <IRazorEngineFeature>());
builder.Features.Add(Mock.Of <IRazorEngineFeature>());
builder.Phases.Add(Mock.Of <IRazorEnginePhase>());
builder.Phases.Add(Mock.Of <IRazorEnginePhase>());
features = builder.Features.ToArray();
phases = builder.Phases.ToArray();
});
// Assert
Assert.Collection(
engine.Features,
f => Assert.Same(features[0], f),
f => Assert.Same(features[1], f));
Assert.Collection(
engine.Phases,
p => Assert.Same(phases[0], p),
p => Assert.Same(phases[1], p));
}
private RazorEngine CreateDesignTimeEngine()
{
return(RazorEngine.CreateDesignTime(b =>
{
// Notice we're not registering the ModelDirective.Pass here so we can run it on demand.
b.AddDirective(ModelDirective.Directive);
// There's some special interaction with the inherits directive
InheritsDirective.Register(b);
}));
}
public void CreateDesignTime_Null_CreatesDefaultDesignTimeEngine()
{
// Arrange
// Act
var engine = RazorEngine.CreateDesignTime(configure: null);
// Assert
Assert.IsType <DefaultRazorEngine>(engine);
AssertDefaultDesignTimeFeatures(engine.Features);
AssertDefaultDesignTimePhases(engine.Phases);
AssertDefaultDesignTimeTargetExtensions(engine);
}
protected RazorEngine CreateDesignTimeEngine(CSharpCompilation compilation)
{
var references = compilation.References.Concat(new[] { compilation.ToMetadataReference() });
return(RazorEngine.CreateDesignTime(b =>
{
RazorExtensions.Register(b);
b.Features.Add(GetMetadataReferenceFeature(references));
b.Features.Add(new CompilationTagHelperFeature());
}));
}
public override RazorTemplateEngine Create(string projectPath, Action <IRazorEngineBuilder> configure)
{
if (projectPath == null)
{
throw new ArgumentNullException(nameof(projectPath));
}
// In 15.5 we expect projectPath to be a directory, NOT the path to the csproj.
var project = FindProject(projectPath);
var configuration = (project?.Configuration as MvcExtensibilityConfiguration) ?? DefaultConfiguration;
RazorEngine engine;
if (configuration.RazorAssembly.Identity.Version.Major == 1)
{
engine = RazorEngine.CreateDesignTime(b =>
{
configure?.Invoke(b);
Mvc1_X.RazorExtensions.Register(b);
if (configuration.MvcAssembly.Identity.Version.Minor >= 1)
{
Mvc1_X.RazorExtensions.RegisterViewComponentTagHelpers(b);
}
});
var templateEngine = new Mvc1_X.MvcRazorTemplateEngine(engine, RazorProject.Create(projectPath));
templateEngine.Options.ImportsFileName = "_ViewImports.cshtml";
return(templateEngine);
}
else
{
engine = RazorEngine.CreateDesignTime(b =>
{
configure?.Invoke(b);
MvcLatest.RazorExtensions.Register(b);
});
var templateEngine = new MvcLatest.MvcRazorTemplateEngine(engine, RazorProject.Create(projectPath));
templateEngine.Options.ImportsFileName = "_ViewImports.cshtml";
return(templateEngine);
}
}
private static RazorSyntaxTree GetSyntaxTree(StringTextSnapshot source, IEnumerable <DirectiveDescriptor> directives = null)
{
directives = directives ?? Enumerable.Empty <DirectiveDescriptor>();
var engine = RazorEngine.CreateDesignTime(builder =>
{
foreach (var directive in directives)
{
builder.AddDirective(directive);
}
});
var sourceDocument = RazorSourceDocument.Create(source.GetText(), "test.cshtml");
var codeDocument = RazorCodeDocument.Create(sourceDocument);
engine.Process(codeDocument);
return(codeDocument.GetSyntaxTree());
}
protected RazorEngine CreateDesignTimeEngine(IEnumerable <MetadataReference> references)
{
return(RazorEngine.CreateDesignTime(b =>
{
RazorExtensions.Register(b);
b.Features.Add(GetMetadataReferenceFeature(references));
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultTagHelperDescriptorProvider()
{
DesignTime = true
});
b.Features.Add(new ViewComponentTagHelperDescriptorProvider()
{
ForceEnabled = true
});
}));
}
public void CSharpDocument_DesignTime_PreservesParserErrors()
{
// Arrange
var engine = RazorEngine.CreateDesignTime();
var document = RazorCodeDocument.Create(TestRazorSourceDocument.Create("@{", fileName: "test.cshtml"));
var expected = RazorDiagnosticFactory.CreateParsing_ExpectedEndOfBlockBeforeEOF(
new SourceSpan(new SourceLocation("test.cshtml", 1, 0, 1), contentLength: 1), Resources.BlockName_Code, "}", "{");
// Act
engine.Process(document);
// Assert
var csharpDocument = document.GetCSharpDocument();
var error = Assert.Single(csharpDocument.Diagnostics);
Assert.Equal(expected, error);
}
private static RazorSyntaxTree GetSyntaxTree(string source)
{
var taghelper = TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("taghelper"))
.TypeName("TestTagHelper")
.Build();
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.AddTagHelpers(taghelper);
});
var sourceDocument = RazorSourceDocument.Create(source, "test.cshtml");
var addTagHelperImport = RazorSourceDocument.Create("@addTagHelper *, TestAssembly", "import.cshtml");
var codeDocument = RazorCodeDocument.Create(sourceDocument, new[] { addTagHelperImport });
engine.Process(codeDocument);
return(codeDocument.GetSyntaxTree());
}
public override RazorTemplateEngine Create(string projectPath, Action <IRazorEngineBuilder> configure)
{
if (projectPath == null)
{
throw new ArgumentNullException(nameof(projectPath));
}
var engine = RazorEngine.CreateDesignTime(b =>
{
configure?.Invoke(b);
// For now we're hardcoded to use MVC's extensibility.
RazorExtensions.Register(b);
});
var templateEngine = new MvcRazorTemplateEngine(engine, RazorProject.Create(projectPath));
templateEngine.Options.ImportsFileName = "_ViewImports.cshtml";
return(templateEngine);
}
public void NamespaceToken()
{
// Arrange
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.ConfigureDocumentClassifier();
builder.AddDirective(DirectiveDescriptor.CreateDirective("custom", DirectiveKind.SingleLine, b => b.AddNamespaceToken()));
});
var document = CreateCodeDocument();
// Act
engine.Process(document);
// Assert
AssertDocumentNodeMatchesBaseline(document.GetDocumentIntermediateNode());
AssertCSharpDocumentMatchesBaseline(document.GetCSharpDocument());
AssertSourceMappingsMatchBaseline(document);
}
private static RazorCodeDocument GetCodeDocument(string source)
{
var taghelper = TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly")
.BoundAttributeDescriptor(attr => attr.Name("show").TypeName("System.Boolean"))
.BoundAttributeDescriptor(attr => attr.Name("id").TypeName("System.Int32"))
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("taghelper"))
.TypeName("TestTagHelper")
.Build();
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.AddTagHelpers(taghelper);
});
var sourceDocument = RazorSourceDocument.Create(source, "test.cshtml");
var addTagHelperImport = RazorSourceDocument.Create("@addTagHelper *, TestAssembly", "import.cshtml");
var codeDocument = RazorCodeDocument.Create(sourceDocument, new[] { addTagHelperImport });
engine.Process(codeDocument);
return(codeDocument);
}
public void CSharpDocument_DesignTime_PreservesParserErrors()
{
// Arrange
var engine = RazorEngine.CreateDesignTime();
var document = RazorCodeDocument.Create(TestRazorSourceDocument.Create("@{", fileName: "test.cshtml"));
var expected = RazorDiagnostic.Create(new RazorError(
LegacyResources.FormatParseError_Expected_EndOfBlock_Before_EOF(LegacyResources.BlockName_Code, "}", "{"),
new SourceLocation("test.cshtml", 1, 0, 1),
length: 1));
// Act
engine.Process(document);
// Assert
var csharpDocument = document.GetCSharpDocument();
var error = Assert.Single(csharpDocument.Diagnostics);
Assert.Equal(expected, error);
}
public CodeGenerationBenchmark()
{
var current = new DirectoryInfo(AppContext.BaseDirectory);
while (current != null && !File.Exists(Path.Combine(current.FullName, "MSN.cshtml")))
{
current = current.Parent;
}
var root = current;
var engine = RazorEngine.Create(b => { RazorExtensions.Register(b); });
var project = RazorProject.Create(root.FullName);
DesignTimeTemplateEngine = new MvcRazorTemplateEngine(RazorEngine.CreateDesignTime(b => { RazorExtensions.Register(b); }), project);
RuntimeTemplateEngine = new MvcRazorTemplateEngine(RazorEngine.Create(b => { RazorExtensions.Register(b); }), project);
var codeDocument = RuntimeTemplateEngine.CreateCodeDocument(Path.Combine(root.FullName, "MSN.cshtml"));
Imports = codeDocument.Imports;
MSN = codeDocument.Source;
}
private static DocumentIntermediateNode LowerDesignTime(RazorCodeDocument codeDocument)
{
var engine = RazorEngine.CreateDesignTime();
return(Lower(codeDocument, engine));
}
