public void ParseMethodCallsParseDocumentOnMarkupParserAndReturnsResults() {
// Arrange
RazorParser parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());
// Act/Assert
ParserTestBase.EvaluateResults(TestContext,
parser.Parse(new StringReader("foo @bar baz")),
new MarkupBlock(
new MarkupSpan("foo "),
new ExpressionBlock(
new TransitionSpan(RazorParser.TransitionString, hidden: false, acceptedCharacters: AcceptedCharacters.None),
new ImplicitExpressionSpan("bar", CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false, acceptedCharacters: AcceptedCharacters.NonWhiteSpace)
),
new MarkupSpan(" baz")
));
}
public void Parse_ParsesDocumentAndInvokesVisitor()
{
// Arrange
var factory = SpanFactory.CreateCsHtml();
var visitor = new Mock<ParserVisitor> { CallBase = true };
var parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());
// Act
parser.Parse(new StringReader("foo @bar baz"), visitor.Object);
// Assert
visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Markup && s.Content == "foo ")));
visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Transition && s.Content == "@")));
visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Code && s.Content == "bar")));
visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Markup && s.Content == " baz")));
}
/// <summary>
/// Compiles the template.
/// </summary>
/// <param name="className">The class name of the dynamic type.</param>
/// <param name="template">The template to compile.</param>
/// <param name="modelType">[Optional] The mode type.</param>
private CompilerResults Compile(string className, string template, Type modelType = null)
{
var languageService = provider.CreateLanguageService();
var codeDom = provider.CreateCodeDomProvider();
var host = new RazorEngineHost(languageService);
var generator = languageService.CreateCodeGenerator(className, "Razor.Dynamic", null, host);
var parser = new RazorParser(languageService.CreateCodeParser(), new HtmlMarkupParser());
Type baseType = (modelType == null)
? typeof(TemplateBase)
: typeof(TemplateBase<>).MakeGenericType(modelType);
generator.GeneratedClass.BaseTypes.Add(baseType);
using (var reader = new StreamReader(new MemoryStream(Encoding.ASCII.GetBytes(template))))
{
parser.Parse(reader, generator);
}
var statement = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Clear");
generator.GeneratedExecuteMethod.Statements.Insert(0, new CodeExpressionStatement(statement));
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
codeDom.GenerateCodeFromCompileUnit(generator.GeneratedCode, writer, new CodeGeneratorOptions());
}
var @params = new CompilerParameters();
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
if (!assembly.IsDynamic)
@params.ReferencedAssemblies.Add(assembly.Location);
}
@params.GenerateInMemory = true;
@params.IncludeDebugInformation = false;
@params.GenerateExecutable = false;
@params.CompilerOptions = "/target:library /optimize";
@params.TempFiles.KeepFiles = KeepFiles;
var result = codeDom.CompileAssemblyFromSource(@params, new[] { builder.ToString() });
return result;
}
private static void RunParseWithListenerTest(Action<RazorParser, TextReader> parserAction)
{
// Arrange
ParserBase markupParser = new MockMarkupParser();
ParserBase codeParser = new CSharpCodeParser();
RazorParser parser = new RazorParser(codeParser, markupParser);
TextReader expectedReader = new StringReader("foo");
// Act
parserAction(parser, expectedReader);
// Assert
ParserContext actualContext = markupParser.Context;
Assert.NotNull(actualContext);
Assert.Same(markupParser, actualContext.MarkupParser);
Assert.Same(markupParser, actualContext.ActiveParser);
Assert.Same(codeParser, actualContext.CodeParser);
}
public void ParseMethodCallsParseDocumentOnMarkupParserAndReturnsResults()
{
var factory = SpanFactory.CreateCsHtml();
// Arrange
RazorParser parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());
// Act/Assert
ParserTestBase.EvaluateResults(parser.Parse(new StringReader("foo @bar baz")),
new MarkupBlock(
factory.Markup("foo "),
new ExpressionBlock(
factory.CodeTransition(),
factory.Code("bar")
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
.Accepts(AcceptedCharacters.NonWhiteSpace)),
factory.Markup(" baz")));
}
private static void RunParseWithListenerTest(Action<RazorParser, TextReader, ParserVisitor> parserAction) {
// Arrange
MarkupParser markupParser = new MockMarkupParser();
ParserBase codeParser = new CSharpCodeParser();
RazorParser parser = new RazorParser(codeParser, markupParser);
TextReader expectedReader = new StringReader("foo");
ParserVisitor expectedListener = new Mock<ParserVisitor>().Object;
// Act
parserAction(parser, expectedReader, expectedListener);
// Assert
ParserContext actualContext = markupParser.Context;
Assert.IsNotNull(actualContext);
Assert.AreSame(markupParser, actualContext.MarkupParser);
Assert.AreSame(markupParser, actualContext.ActiveParser);
Assert.AreSame(codeParser, actualContext.CodeParser);
Assert.AreSame(expectedReader, ((BufferingTextReader)actualContext.Source).InnerReader);
Assert.AreSame(expectedListener, actualContext.Visitor);
}
public void ParseMethodUsesProvidedParserListenerIfSpecified() {
// Arrange
RazorParser parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());
SyntaxTreeBuilderVisitor builder = new SyntaxTreeBuilderVisitor();
// Act
parser.Parse(new StringReader("foo @bar baz"), builder);
// Assert
ParserTestBase.EvaluateResults(TestContext,
builder.Results,
new MarkupBlock(
new MarkupSpan("foo "),
new ExpressionBlock(
new TransitionSpan(RazorParser.TransitionString, hidden: false, acceptedCharacters: AcceptedCharacters.None),
new ImplicitExpressionSpan("bar", CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false, acceptedCharacters: AcceptedCharacters.NonWhiteSpace)
),
new MarkupSpan(" baz")
));
}
public void ParseMethodUsesProvidedParserListenerIfSpecified()
{
var factory = SpanFactory.CreateCsHtml();
// Arrange
RazorParser parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());
// Act
ParserResults results = parser.Parse(new StringReader("foo @bar baz"));
// Assert
ParserTestBase.EvaluateResults(results,
new MarkupBlock(
factory.Markup("foo "),
new ExpressionBlock(
factory.CodeTransition(),
factory.Code("bar")
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
.Accepts(AcceptedCharacters.NonWhiteSpace)),
factory.Markup(" baz")));
}
private CompilerResults Compile(string className, string template, IEnumerable<string> additionalNamespaces, Type modelType = null)
{
var languageService = provider.CreateLanguageService();
var codeDom = provider.CreateCodeDomProvider();
var host = new RazorEngineHost(languageService);
host.NamespaceImports.Add("System");
host.NamespaceImports.Add("System.Collections.Generic");
host.NamespaceImports.Add("System.IO");
host.NamespaceImports.Add("System.Linq");
host.NamespaceImports.Add("RazorTex");
if (additionalNamespaces != null)
{
additionalNamespaces.ToList().ForEach(p => host.NamespaceImports.Add(p));
}
//Razor.importedNamespaces.ForEach(p => host.NamespaceImports.Add(p));
var generator = languageService.CreateCodeGenerator(className, "Razor.Dynamic", null, host);
var parser = new RazorParser(languageService.CreateCodeParser(), new HtmlMarkupParser()); //FIXME!
// TODO: Make this association file-type dependent!
Type baseType = (modelType == null)
? typeof(LatexTemplate)
: typeof(LatexTemplate<>).MakeGenericType(modelType);
generator.GeneratedClass.BaseTypes.Add(baseType);
using(StreamReader reader = new StreamReader(new MemoryStream(Encoding.ASCII.GetBytes(template))))
{
parser.Parse(reader, generator);
}
var statement = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Clear");
generator.GeneratedExecuteMethod.Statements.Insert(0, new CodeExpressionStatement(statement));
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
codeDom.GenerateCodeFromCompileUnit(generator.GeneratedCode, writer, new CodeGeneratorOptions());
}
var @params = new CompilerParameters();
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
if (assembly.IsDynamic)
continue;
try
{
@params.ReferencedAssemblies.Add(assembly.Location);
}
catch (Exception ex)
{
}
}
@params.GenerateInMemory = true;
@params.IncludeDebugInformation = false;
@params.GenerateExecutable = false;
@params.CompilerOptions = "/target:library /optimize";
string source = builder.ToString();
var result = codeDom.CompileAssemblyFromSource(@params, new[] { source });
return result;
}
public async Task CreateParseTask_ReturnsWithoutThrowingIfTaskIsCancelled()
{
// Arrange
var factory = SpanFactory.CreateCsHtml();
var visitor = new Mock<ParserVisitor> { CallBase = true };
var parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());
var cancelTokenSource = new CancellationTokenSource();
var visited = false;
// Act
var task = parser.CreateParseTask(new StringReader("foo @bar baz"),
(span) =>
{
visited = true;
Assert.Equal("foo ", span.Content);
cancelTokenSource.Cancel();
},
errorCallback: null,
cancelToken: cancelTokenSource.Token);
task.Start();
await task;
// Assert
Assert.True(visited);
}
/// <summary>
/// Parses the specified template.
/// </summary>
/// <param name="template">The string template to parse.</param>
/// <param name="parser">The parser.</param>
/// <param name="visitor">The parser visitor.</param>
private static void ParseTemplate(string template, RazorParser parser, ParserVisitor visitor)
{
using (var reader = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(template))))
{
parser.Parse(reader, visitor);
}
}
/// <summary>
/// Compiles the string cshtml template into a cs string
/// </summary>
/// <param name="className">The name of the compiled class.</param>
/// <param name="template">The template to compile.</param>
/// <param name="modelType">[Optional] The model type.</param>
/// <param name="baseTypeName">[Optional] Base type for the template. To be used if the model type is
/// in an unreferenced assembly.</param>
/// <returns>The results of compilation.</returns>
public string GetCode(string className, string template, Type modelType = null, string baseTypeName = null, string outputNamespace = null)
{
if (className == null)
{
className = Regex.Replace(Guid.NewGuid().ToString("N"), @"[^A-Za-z]*", "");
}
var service = languageProvider.CreateLanguageService();
var codeDom = languageProvider.CreateCodeDomProvider();
var host = new RazorEngineHost(service);
host.GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo", "WriteLiteralTo", "RazorEngine.Templating.TemplateWriter");
var generator = service.CreateCodeGenerator(className, outputNamespace ?? "RazorEngine.Dynamic", null, host);
var codeParser = service.CreateCodeParser();
var parser = new RazorParser(codeParser, markupParser);
AddNamespaceImports(generator.GeneratedNamespace);
string baseType = baseTypeName;
if (baseTypeName == null)
{
baseType = GetBaseTypeDeclaration(languageProvider, modelType, templateBaseType);
}
generator.GeneratedClass.BaseTypes.Add(baseType);
if ((modelType != null) && IsAnonymousType(modelType))
generator.GeneratedClass.CustomAttributes.Add(
new CodeAttributeDeclaration(
new CodeTypeReference(typeof(HasDynamicModelAttribute))));
ParseTemplate(template, parser, generator);
var builder = new StringBuilder();
GenerateCode(codeDom, generator, builder);
return builder.ToString();
}
private static Span[] GenerateSpans(string text, SpanKind spanKind, int spanIndex, string spanText)
{
Assert.True(spanIndex > 0);
RazorParser parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());
Span[] spans;
using (var reader = new StringReader(text))
{
ParserResults results = parser.Parse(reader);
spans = results.Document.Flatten().ToArray();
}
Assert.True(spans.Length > spanIndex);
Assert.Equal(spanKind, spans[spanIndex].Kind);
Assert.Equal(spanText, spans[spanIndex].Content);
return spans;
}
void ParseTemplate(string html)
{
var parser = new RazorParser(codeLanguage.CreateCodeParser(), new HtmlMarkupParser());
parserResults = parser.Parse(new StringReader(html));
}
