/// <inheritdoc />
public override RazorParser DecorateRazorParser(RazorParser razorParser, string sourceFileName)
{
if (razorParser == null)
{
throw new ArgumentNullException(nameof(razorParser));
}
var inheritedChunkTrees = GetInheritedChunkTrees(sourceFileName);
return(new MvcRazorParser(razorParser, inheritedChunkTrees, DefaultInheritedChunks, ModelExpressionType));
}
public static RazorSyntaxTree Parse(RazorSourceDocument source, RazorParserOptions options)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var parser = new RazorParser(options ?? RazorParserOptions.CreateDefault());
return(parser.Parse(source));
}
/// <summary>
/// Initializes a new instance of <see cref="MvcRazorParser"/>.
/// </summary>
/// <param name="parser">The <see cref="RazorParser"/> to copy properties from.</param>
/// <param name="inheritedCodeTrees">The <see cref="IReadOnlyList{CodeTree}"/>s that are inherited
/// from parsed pages from _GlobalImport files.</param>
/// <param name="defaultInheritedChunks">The <see cref="IReadOnlyList{Chunk}"/> inherited by
/// default by all Razor pages in the application.</param>
public MvcRazorParser(
[NotNull] RazorParser parser,
[NotNull] IReadOnlyList <CodeTree> inheritedCodeTrees,
[NotNull] IReadOnlyList <Chunk> defaultInheritedChunks)
: base(parser)
{
// Construct tag helper descriptors from @addTagHelper, @removeTagHelper and @tagHelperPrefix chunks
_globalImportDirectiveDescriptors = GetTagHelperDirectiveDescriptors(
inheritedCodeTrees,
defaultInheritedChunks);
}
/// <summary>
/// Provides an opportunity for derived types to modify the instance of <see cref="RazorParser"/>
/// used by the <see cref="RazorTemplateEngine"/> to parse the Razor tree.
/// </summary>
/// <param name="incomingRazorParser">The <see cref="RazorParser"/></param>
/// <param name="sourceFileName">The file name of the Razor file being parsed.</param>
/// <returns>Either the same code parser, after modifications, or a different code parser.</returns>
public virtual RazorParser DecorateRazorParser(
RazorParser incomingRazorParser,
string sourceFileName)
{
if (incomingRazorParser == null)
{
throw new ArgumentNullException(nameof(incomingRazorParser));
}
return(incomingRazorParser);
}
protected internal virtual ParserResults ParseTemplateCore(
ITextDocument input,
CancellationToken?cancelToken
)
{
// Construct the parser
RazorParser parser = CreateParser();
Debug.Assert(parser != null);
return(parser.Parse(input));
}
public string Render()
{
List <Assembly> references = new List <Assembly>(GetDefaultAssembliesToReference());
references.Add(typeof(PropertyInfo).Assembly);
RazorParser <DtoTemplate> parser = new RazorParser <DtoTemplate>(RazorBaseTemplate.DefaultInspector);
string output = parser.ExecuteResource("Dto.tmpl", "Bam.Net.Data.Repositories.Templates.", typeof(DtoTemplate).Assembly,
new { Model = this }, references.ToArray());
return(output);
}
private void AddVirtualDocuments(RazorCodeDocument document, string relativePath)
{
foreach (var item in _project.EnumerateAscending(relativePath, ".razor"))
{
if (item.Filename == "_PageImports.razor")
{
var source = item.ToSourceDocument();
var parsed = RazorParser.Parse(source);
document.AddVirtualSyntaxTree(parsed);
}
}
}
public string Render()
{
List <Assembly> referenceAssemblies = new List <Assembly> {
typeof(DaoGenerator).Assembly,
typeof(ServiceProxyController).Assembly,
typeof(Args).Assembly,
typeof(DaoRepository).Assembly
};
RazorParser <SchemaRepositoryTemplate> parser = new RazorParser <SchemaRepositoryTemplate>(RazorBaseTemplate.DefaultInspector);
string output = parser.ExecuteResource("SchemaRepository.tmpl", "Bam.Net.Data.Repositories.Templates.", typeof(SchemaRepositoryModel).Assembly, new { Model = this }, referenceAssemblies.ToArray());
return(output);
}
public static IIndentationGrammarAnalysis <SyntaxToken, SyntaxNode, GNode> match <GNode, TParent, T>(
this IIndentationGrammarAnalysis <SyntaxToken, SyntaxNode, GNode> self,
IEnumerable <string> patterns,
Action <IIndentationGrammarAnalysis <SyntaxToken, SyntaxNode, GNode> > children = null,
Action <TParent, T> then = null) where T : GNode, new()
{
foreach (var pattern in patterns)
{
match <GNode, TParent, T>(self, RazorParser.Create <T>(pattern), children, then);
}
return(self);
}
public void CreateParserMethodIsConstructedFromHost()
{
// Arrange
RazorEngineHost host = CreateHost();
RazorTemplateEngine engine = new RazorTemplateEngine(host);
// Act
RazorParser parser = engine.CreateParser();
// Assert
Assert.IsType <CSharpCodeParser>(parser.CodeParser);
Assert.IsType <HtmlMarkupParser>(parser.MarkupParser);
}
/// <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);
}
public void CreateParserMethodSetsParserContextToDesignTimeModeIfHostSetToDesignTimeMode()
{
// Arrange
RazorEngineHost host = CreateHost();
RazorTemplateEngine engine = new RazorTemplateEngine(host);
host.DesignTimeMode = true;
// Act
RazorParser parser = engine.CreateParser();
// Assert
Assert.True(parser.DesignTimeMode);
}
public string Render()
{
List <Assembly> referenceAssemblies = new List <Assembly>
{
typeof(OpenApiObjectDatabase).Assembly,
typeof(ServiceProxyHelper).Assembly,
typeof(Args).Assembly
};
RazorParser <RazorTemplate <OpenApiFixedFieldModel> > parser = new RazorParser <RazorTemplate <OpenApiFixedFieldModel> >();
string result = parser.ExecuteResource("FixedField.tmpl", "Bam.Net.Services.OpenApi.Templates.", typeof(OpenApiObjectDatabase).Assembly, new { Model = this }, referenceAssemblies.ToArray());
return(result);
}
private string Render <T>(string templateName, object options)
{
List <Assembly> referenceAssemblies = new List <Assembly> {
typeof(DaoGenerator).Assembly,
typeof(ServiceProxyController).Assembly,
typeof(Args).Assembly,
typeof(DaoRepository).Assembly
};
RazorParser <RazorTemplate <T> > parser = new RazorParser <RazorTemplate <T> >();
string result = parser.ExecuteResource(templateName, "Bam.Net.Data.Repositories.Templates.", typeof(SchemaRepositoryTemplate).Assembly, options, referenceAssemblies.ToArray()).Trim();
return(result);
}
protected internal virtual RazorParser CreateParser(string sourceFileName)
{
var codeParser = Host.CodeLanguage.CreateCodeParser();
var markupParser = Host.CreateMarkupParser();
var parser = new RazorParser(Host.DecorateCodeParser(codeParser),
Host.DecorateMarkupParser(markupParser),
Host.TagHelperDescriptorResolver)
{
DesignTimeMode = Host.DesignTimeMode
};
return(Host.DecorateRazorParser(parser, sourceFileName));
}
/// <summary>
/// Initializes a new instance of <see cref="MvcRazorParser"/>.
/// </summary>
/// <param name="parser">The <see cref="RazorParser"/> to copy properties from.</param>
/// <param name="inheritedChunkTrees">The <see cref="IReadOnlyList{ChunkTree}"/>s that are inherited
/// from parsed pages from _ViewImports files.</param>
/// <param name="defaultInheritedChunks">The <see cref="IReadOnlyList{Chunk}"/> inherited by
/// default by all Razor pages in the application.</param>
public MvcRazorParser(
[NotNull] RazorParser parser,
[NotNull] IReadOnlyList <ChunkTree> inheritedChunkTrees,
[NotNull] IReadOnlyList <Chunk> defaultInheritedChunks,
[NotNull] string modelExpressionTypeName)
: base(parser)
{
// Construct tag helper descriptors from @addTagHelper, @removeTagHelper and @tagHelperPrefix chunks
_viewImportsDirectiveDescriptors = GetTagHelperDirectiveDescriptors(
inheritedChunkTrees,
defaultInheritedChunks);
_modelExpressionTypeName = modelExpressionTypeName;
}
public void WriteContextMethods(Table table, string ns)
{
RazorParser <TableTemplate> razorParser = new RazorParser <TableTemplate>();
razorParser.GetDefaultAssembliesToReference = () =>
{
Assembly[] assembliesToReference = new Assembly[] { typeof(SchemaTemplate).Assembly,
typeof(DaoGenerator).Assembly,
typeof(ServiceProxySystem).Assembly,
typeof(Providers).Assembly };
return(assembliesToReference);
};
Write(razorParser.ExecuteResource("ContextMethods.tmpl", "Bam.Net.Data.Schema.Templates.", typeof(SchemaTemplate).Assembly, new { Model = table, Namespace = ns }));
}
protected virtual Type Load(RazorSourceDocument source, string relativePath)
{
var document = _engine.CreateCodeDocument(source);
var parsed = RazorParser.Parse(source);
document.SetSyntaxTree(RazorParser.Parse(source));
foreach (var error in parsed.Diagnostics)
{
document.ErrorSink.OnError(error);
}
AddVirtualDocuments(document, relativePath);
var @namespace = GetNamespace(relativePath);
var @class = "Generated_" + Path.GetFileNameWithoutExtension(Path.GetFileName(relativePath));
document.WithClassName(@namespace, @class);
_engine.Process(document);
if (document.ErrorSink.Errors.Any())
{
throw CreateException(document);
}
var compilation = CreateCompilation(@class, @namespace, relativePath, document.GetGeneratedCSharpDocument().GeneratedCode);
var text = compilation.SyntaxTrees[0].ToString();
using (var pe = new MemoryStream())
{
using (var pdb = new MemoryStream())
{
var emitResult = compilation.Emit(
peStream: pe,
pdbStream: pdb,
options: new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb));
if (!emitResult.Success)
{
throw CreateException(document, relativePath, text, compilation.AssemblyName, emitResult.Diagnostics);
}
pe.Seek(0, SeekOrigin.Begin);
pdb.Seek(0, SeekOrigin.Begin);
var assembly = LoadStream(pe, pdb);
var type = assembly.GetExportedTypes().FirstOrDefault(a => !a.IsNested);
return(type);
}
}
}
public async Task <string> BuildConfirmEmailBody(Reservation reservation)
{
var template = "Templates.ReservationConfirmation";
reservation.Room = await roomService.FindRoomWithAllProperties(reservation.RoomId);
RazorParser renderer = new RazorParser(typeof(EmailClient).Assembly, memoryCache);
var body = renderer.UsingTemplateFromEmbedded(template, new ReservationConfirmationEmail
{
Reservation = reservation,
BedTypes = bedService.GetBedTypesAsString(reservation.Room.RoomBeds)
});
return(body);
}
public IActionResult Parse([FromBody] Source source)
{
var document = RazorSourceDocument.Create(source.Content, fileName: null);
var options = RazorParserOptions.Create(builder => {
foreach (var directive in GetDirectives())
{
builder.Directives.Add(directive);
}
});
var parser = new RazorParser(options);
var tree = parser.Parse(document, legacy: true);
var result = TreeSerializer.Serialize(tree);
return(Content(result));
}
private static void Send(string language, EmailTemplate templateId, Notification notification)
{
var emailAction = new SendEmailAction {
EmailToList = new List <XmlEmail>(), TemplateId = templateId
};
emailAction.EmailToList.Add(new XmlEmail {
Email = notification.Email
});
var parser = new RazorParser(language);
string subject = parser.ParseSubject(emailAction, notification);
string body = parser.ParseTemplate(emailAction, notification, subject);
EmailManager.Send(emailAction, subject, body);
}
public void ProcessDirectives_CanReturnEmptyDescriptorsBasedOnDirectiveDescriptors(
string source,
object tagHelpers)
{
// Arrange
var sourceDocument = TestRazorSourceDocument.Create(source, filePath: "TestFile");
var parser = new RazorParser();
var syntaxTree = parser.Parse(sourceDocument);
var visitor = new DefaultRazorTagHelperBinderPhase.DirectiveVisitor((TagHelperDescriptor[])tagHelpers);
// Act
visitor.VisitBlock(syntaxTree.Root);
// Assert
Assert.Empty(visitor.Matches);
}
public void DirectiveVisitor_ExtractsPrefixFromSyntaxTree(
string source,
string expectedPrefix)
{
// Arrange
var sourceDocument = TestRazorSourceDocument.Create(source, filePath: "TestFile");
var parser = new RazorParser();
var syntaxTree = parser.Parse(sourceDocument);
var visitor = new DefaultRazorTagHelperBinderPhase.DirectiveVisitor(tagHelpers: new List <TagHelperDescriptor>());
// Act
visitor.VisitBlock(syntaxTree.Root);
// Assert
Assert.Equal(expectedPrefix, visitor.TagHelperPrefix);
}
protected internal virtual ParserResults ParseTemplateCore(LookaheadTextReader input, CancellationToken?cancelToken)
{
// Setup the consumer
SyntaxTreeBuilderVisitor treeBuilder = new SyntaxTreeBuilderVisitor()
{
CancelToken = cancelToken
};
// Construct the parser
RazorParser parser = CreateParser();
Debug.Assert(parser != null);
parser.Parse(input, treeBuilder);
// Return the results
return(treeBuilder.Results);
}
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")
));
}
/// <summary>
/// Send async email
/// </summary>
/// <param name="destination"></param>
/// <param name="peoples"></param>
/// <returns></returns>
public void BatchSend(string destination, IEnumerable <Person> peoples)
{
//destination
if (string.IsNullOrWhiteSpace(destination))
{
throw new ArgumentNullException("destination");
}
//check peoples
if (peoples == null || !peoples.Any())
{
throw new ArgumentNullException("peoples");
}
// Partition the entire source array.
//https://msdn.microsoft.com/en-us/library/dd997411(v=vs.110).aspx
var rangePartitioner = Partitioner.Create(0, peoples.Count(), _configuration.AttachmentSize);
// Loop over the partitions
var rangePartitions = rangePartitioner.GetDynamicPartitions();
foreach (var rangePartition in rangePartitions)
{
var attachments = new string[rangePartition.Item2 - rangePartition.Item1];
var attachmentIndex = 0;
// Loop over each range element without a delegate invocation.
for (var counter = rangePartition.Item1; counter < rangePartition.Item2; counter++)
{
var person = peoples.ElementAt(counter);
var html = RazorParser.Compile(_configuration.TemplatePath, person);
var pdf = iTextSharpFactory.Convert(html);
var tmpPath = Path.Combine(Path.GetTempPath(), string.Format("{0}_{1}.pdf", person.FullName, Path.GetFileNameWithoutExtension(Path.GetRandomFileName())));
File.WriteAllBytes(tmpPath, pdf);
attachments[attachmentIndex] = tmpPath;
attachmentIndex++;
}
var subject = string.Format("Criminal Profiles - Part {0}/{1}", rangePartition.Item1 + 1, rangePartition.Item2);
var body = @"Hi, we are sending you the results of your search. Please open the attached files.";
SendGridTool.Send(_configuration.EmailProviderKey, _configuration.FromEmail, destination, subject, body, attachments);
}
}
public IEnumerable <SearchResult> Search(CancellationToken cancelToken = default(CancellationToken))
{
var visitor = new LiteralParserVisitor()
{
Path = Path,
CancelToken = cancelToken,
ExcludedLines = GetExcludedLines(),
};
var parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());
parser.Parse(this.Reader, visitor);
visitor.EndText();
return(visitor.Results);
}
protected internal virtual GeneratorResults GenerateCodeCore(
ITextDocument input,
string className,
string rootNamespace,
string sourceFileName,
CancellationToken?cancelToken
)
{
className = (className ?? Host.DefaultClassName) ?? DefaultClassName;
rootNamespace = (rootNamespace ?? Host.DefaultNamespace) ?? DefaultNamespace;
// Run the parser
RazorParser parser = CreateParser();
Debug.Assert(parser != null);
ParserResults results = parser.Parse(input);
// Generate code
RazorCodeGenerator generator = CreateCodeGenerator(
className,
rootNamespace,
sourceFileName
);
generator.DesignTimeMode = Host.DesignTimeMode;
generator.Visit(results);
// Post process code
Host.PostProcessGeneratedCode(generator.Context);
// Extract design-time mappings
IDictionary <int, GeneratedCodeMapping> designTimeLineMappings = null;
if (Host.DesignTimeMode)
{
designTimeLineMappings = generator.Context.CodeMappings;
}
// Collect results and return
return(new GeneratorResults(
results,
generator.Context.CompileUnit,
designTimeLineMappings
));
}
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")));
}
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")));
}
