private static CompileToCSharpResult CompileToCSharp(string cshtmlRootPath, string cshtmlRelativePath, string cshtmlContent, string outputNamespace) { using (var resultStream = new MemoryStream()) using (var resultWriter = new StreamWriter(resultStream)) using (var verboseLogStream = new MemoryStream()) using (var verboseWriter = new StreamWriter(verboseLogStream)) using (var inputContents = new MemoryStream(Encoding.UTF8.GetBytes(cshtmlContent))) { var diagnostics = new RazorCompiler().CompileSingleFile( cshtmlRootPath, cshtmlRelativePath, inputContents, outputNamespace, resultWriter, verboseWriter); resultWriter.Flush(); verboseWriter.Flush(); return(new CompileToCSharpResult { Code = Encoding.UTF8.GetString(resultStream.ToArray()), VerboseLog = Encoding.UTF8.GetString(verboseLogStream.ToArray()), Diagnostics = diagnostics }); } }
public override bool TryGetMember(GetMemberBinder binder, out object result) { Type modelType = Model.GetType(); var prop = modelType.GetProperty(binder.Name); if (prop == null) { result = null; return(false); } object value = prop.GetValue(Model, null); if (value == null) { result = value; return(true); } Type valueType = value.GetType(); result = (RazorCompiler.IsAnonymousType(valueType)) ? new RazorDynamicObject { Model = value } : value; return(true); }
public void SetRazorCompiler(RazorCompiler razorCompiler) { if (razorCompiler != null && _razorCompiler == null) { _razorCompiler = razorCompiler; } }
/// <summary> /// Initialises a new instance of <see cref="TemplateService"/>. /// </summary> /// <param name="provider">[Optional] The language provider to use.</param> /// <param name="templateBaseType">[Optional] The base template type.</param> /// <param name="parser">[Optional] The markup parser to use.</param> public TemplateService(ILanguageProvider provider = null, Type templateBaseType = null, MarkupParser parser = null) { cache = new Dictionary <string, ITemplate>(); provider = provider ?? new CSharpLanguageProvider(); compiler = new RazorCompiler(provider, templateBaseType, parser); }
public void Empty_String_Compiles() { ListErrors(() => { RazorCompiler compiler = new RazorCompiler(); var template = compiler.Compile<TestRazorTemplate<string>>(""); }); }
public void Echo_Script_Compiles() { ListErrors(() => { RazorCompiler compiler = new RazorCompiler(); var template = compiler.Compile<TestRazorTemplate<string>>("@Model"); }); }
public static void Main(string[] args) { var compiler = new RazorCompiler(); var template = compiler.Compile<HelloRazorTemplate>("Hello @Name."); Console.WriteLine(template.Run("Bob Freeman")); Console.WriteLine("Press any key to continue..."); Console.ReadKey(); }
public void Html_Is_Not_Escaped_When_Using_Raw() { ListErrors(() => { RazorCompiler compiler = new RazorCompiler(); var template = compiler.Compile<TestHtmlRazorTemplate<string>>("@Html.Raw(@Model)"); Assert.AreEqual("<strong>Hello World!</strong>", template.Run("<strong>Hello World!</strong>")); }); }
public void Html_Is_Escaped() { ListErrors(() => { RazorCompiler compiler = new RazorCompiler(); var template = compiler.Compile<TestHtmlRazorTemplate<string>>("@Model"); Assert.AreEqual("<strong>Hello World!</strong>", template.Run("<strong>Hello World!</strong>")); }); }
public RazorCompiler GetRazorCompiler() { if (_razorCompiler == null) { _razorCompiler = new RazorPageCompiler(); } return(_razorCompiler); }
public void Create_Returns_Instance_Which_Can_Be_Run() { ListErrors(() => { RazorCompiler compiler = new RazorCompiler(); var factory = compiler.CompileFactory<TestRazorTemplate<string>>("@Model"); var template = factory.Create(); Assert.AreEqual("<strong>Hello World!</strong>", template.Run("<strong>Hello World!</strong>")); }); }
public void Create_Returns_New_Instances_Each_Time() { ListErrors(() => { RazorCompiler compiler = new RazorCompiler(); var factory = compiler.CompileFactory<TestRazorTemplate<string>>("@Model"); var template1 = factory.Create(); var template2 = factory.Create(); Assert.AreNotSame(template1, template2); }); }
public static void Command(CommandLineApplication command) { // Later, we might want to have the complete list of inputs passed in from MSBuild // so developers can include/exclude whatever they want. The MVC Razor view precompiler // does this by writing the list to a temporary 'response' file then passing the path // to that file into its build executable (see: https://github.com/aspnet/MvcPrecompilation/blob/dev/src/Microsoft.AspNetCore.Mvc.Razor.ViewCompilation/build/netstandard2.0/Microsoft.AspNetCore.Mvc.Razor.ViewCompilation.targets) // For now it's sufficient to assume we want to include '<sourcedir>**\*.cshtml' var sourceDirPath = command.Option("--source", "The path to the directory containing Razor files", CommandOptionType.SingleValue); var outputFilePath = command.Option("--output", "The location where the resulting C# source file should be written", CommandOptionType.SingleValue); var baseNamespace = command.Option("--namespace", "The base namespace for the generated C# classes.", CommandOptionType.SingleValue); var verboseFlag = command.Option("--verbose", "Indicates that verbose console output should written", CommandOptionType.NoValue); command.OnExecute(() => { if (!VerifyRequiredOptionsProvided(sourceDirPath, outputFilePath, baseNamespace)) { return(1); } var sourceDirPathValue = sourceDirPath.Value(); if (!Directory.Exists(sourceDirPathValue)) { Console.WriteLine($"ERROR: Directory not found: {sourceDirPathValue}"); return(1); } var inputRazorFilePaths = FindRazorFiles(sourceDirPathValue).ToList(); using (var outputWriter = new StreamWriter(outputFilePath.Value())) { var diagnostics = new RazorCompiler().CompileFiles( sourceDirPathValue, inputRazorFilePaths, baseNamespace.Value(), outputWriter, verboseFlag.HasValue() ? Console.Out : null); foreach (var diagnostic in diagnostics) { Console.WriteLine(diagnostic.FormatForConsole()); } var hasError = diagnostics.Any(item => item.Type == RazorCompilerDiagnostic.DiagnosticType.Error); return(hasError ? 1 : 0); } }); }
public RazorRenderer(MarkdownTransformer markdownTransformer, Logger logger) { this.markdownTransformer = markdownTransformer; this.logger = logger; this.compiler = new RazorCompiler(); this.compiler.NamespaceImports.Add("System.Linq"); this.compiler.NamespaceImports.Add("Gatsby"); this.includes = new Dictionary<string, Include>(); this.layouts = new Dictionary<string, Layout>(); }
public async Task GenerateEpubAsync(string epubDest, GenerateOptions options) { OpfFile opf = new OpfFile(new OpfMetadata { Title = { Text = Title }, Language = { Text = Language }, Description = { Text = Description }, Creator = { Text = Creator }, Publisher = { Text = Publisher } }); string tmpDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); string epub = Path.Combine(tmpDir, "EPUB"); string metaInf = Path.Combine(tmpDir, "META-INF"); Directory.CreateDirectory(tmpDir); Directory.CreateDirectory(epub); Directory.CreateDirectory(Path.Combine(epub, "covers")); Directory.CreateDirectory(Path.Combine(epub, "css")); Directory.CreateDirectory(Path.Combine(epub, "fonts")); Directory.CreateDirectory(Path.Combine(epub, "images")); Directory.CreateDirectory(metaInf); File.WriteAllText(Path.Combine(tmpDir, "mimetype"), "application/epub+zip"); Container container = new Container(); container.AddRootFile(new RootFile { FullPath = "EPUB/package.opf", MediaType = "application/oebps-package+xml" }); container.Save(Path.Combine(metaInf, "container.xml")); if (!string.IsNullOrEmpty(CoverImage)) { string coverExt = Path.GetExtension(CoverImage); MediaType mType = MediaType.FromExtension(coverExt); if (mType != MediaType.PngType && mType != MediaType.JpegType) { throw new Exception("Invalid cover image extension!"); } string coverImgFile = Path.GetFileName(CoverImage); string coverImg = Path.Combine("covers", coverImgFile); Uri coverImgUri; if (Uri.TryCreate(CoverImage, UriKind.RelativeOrAbsolute, out coverImgUri)) { if (!coverImgUri.IsFile) { using (WebClient wc = new WebClient()) await wc.DownloadFileTaskAsync(CoverImage, Path.Combine(epub, coverImg)); } else if (File.Exists(CoverImage)) { File.Copy(CoverImage, Path.Combine(epub, coverImg)); } OpfItem coverImageItem = new OpfItem(coverImg.Replace(@"\", "/"), Path.GetFileNameWithoutExtension(coverImg), mType) { Linear = false, Properties = "cover-image" }; OpfItem coverItem = new OpfItem("cover.xhtml", "cover", MediaType.XHtmlType); File.WriteAllText(Path.Combine(epub, "cover.xhtml"), RazorCompiler.Get(Templates[EBookTemplate.Cover], "cover", $"covers/{coverImgFile}")); opf.AddItem(coverItem); opf.AddItem(coverImageItem, false); } } TableOfContents toc = new TableOfContents { Title = Title }; OpfItem navItem = new OpfItem("toc.xhtml", "toc", MediaType.XHtmlType) { Properties = "nav" }; opf.AddItem(navItem); var parser = new HtmlParser(); foreach (Chapter chapter in Chapters) { var doc = parser.Parse(chapter.Content); if (options.EmbedImages) { await EmbedImagesAsync(doc, opf, chapter, Path.Combine(epub, "images")); } else { chapter.Content = doc.QuerySelector("body").ChildNodes.ToHtml(new XmlMarkupFormatter()); } string randomFile = Path.GetRandomFileName() + ".xhtml"; OpfItem item = new OpfItem(randomFile, StringUtilities.GenerateRandomString(6), MediaType.XHtmlType); opf.AddItem(item); File.WriteAllText(Path.Combine(epub, randomFile), RazorCompiler.Get(Templates[EBookTemplate.Chapter], "chapter", chapter)); toc.Sections.Add(new Section { Name = chapter.Name, Href = randomFile }); } string tocFile = Path.Combine(epub, "toc.xhtml"); File.WriteAllText(tocFile, RazorCompiler.Get(Templates[EBookTemplate.TableOfContents], "toc", toc)); opf.Save(Path.Combine(epub, "package.opf")); if (File.Exists(epubDest)) { File.Delete(epubDest); } using (FileStream fs = new FileStream(epubDest, FileMode.CreateNew)) using (ZipArchive za = new ZipArchive(fs, ZipArchiveMode.Create)) { za.CreateEntryFromFile(Path.Combine(tmpDir, "mimetype"), "mimetype", CompressionLevel.NoCompression); Zip(za, epub, "EPUB"); Zip(za, metaInf, "META-INF"); } Directory.Delete(tmpDir, true); }