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);
}
