/// <inheritdoc />
public GeneratorResults GenerateCode(string rootRelativePath, Stream inputStream)
{
var className = ParserHelpers.SanitizeClassName(rootRelativePath);
var engine = new RazorTemplateEngine(this);
return(engine.GenerateCode(inputStream, className, DefaultNamespace, rootRelativePath));
}
private static ChunkTree ParseViewFile(
RazorTemplateEngine engine,
IFileInfo fileInfo,
string viewImportsPath)
{
using (var stream = fileInfo.CreateReadStream())
{
using (var streamReader = new StreamReader(stream))
{
var parseResults = engine.ParseTemplate(streamReader, viewImportsPath);
var className = ParserHelpers.SanitizeClassName(fileInfo.Name);
var language = engine.Host.CodeLanguage;
var chunkGenerator = language.CreateChunkGenerator(
className,
engine.Host.DefaultNamespace,
viewImportsPath,
engine.Host);
chunkGenerator.Visit(parseResults);
// Rewrite the location of inherited chunks so they point to the global import file.
var chunkTree = chunkGenerator.Context.ChunkTreeBuilder.Root;
foreach (var chunk in chunkTree.Children)
{
chunk.Start = new SourceLocation(
viewImportsPath,
chunk.Start.AbsoluteIndex,
chunk.Start.LineIndex,
chunk.Start.CharacterIndex);
}
return(chunkTree);
}
}
}
public GeneratorResults GenerateCode(string rootRelativePath, Stream inputStream)
{
StreamReader sr = new StreamReader(inputStream);
var className = MainClassNamePrefix + ParserHelpers.SanitizeClassName(rootRelativePath);
var engine = new RazorTemplateEngine(_host);
return(engine.GenerateCode(GenerateStreamFromString(MinifyChunk(sr.ReadToEnd())), className, DefaultNamespace, rootRelativePath));
}
protected virtual string GetClassName(string virtualPath)
{
// Remove "~/" and run through our santizer
// For example, for ~/Foo/Bar/Baz.cshtml, the class name is _Page_Foo_Bar_Baz_cshtml
return(ParserHelpers.SanitizeClassName(
PageClassNamePrefix + virtualPath.TrimStart('~', '/')
));
}
/// <inheritdoc />
public GeneratorResults GenerateCode(string rootRelativePath, Stream inputStream)
{
// Adding a prefix so that the main view class can be easily identified.
var className = MainClassNamePrefix + ParserHelpers.SanitizeClassName(rootRelativePath);
var engine = new RazorTemplateEngine(this);
return(engine.GenerateCode(inputStream, className, DefaultNamespace, rootRelativePath));
}
public GeneratorResults GenerateCode(string rootRelativePath, Stream inputStream)
{
var className = ParserHelpers.SanitizeClassName(rootRelativePath);
using (var reader = new StreamReader(inputStream))
{
var engine = new RazorTemplateEngine(this);
return(engine.GenerateCode(reader, className, ViewNamespace, rootRelativePath));
}
}
public static string SanitizeNamespace(string inputName)
{
var sections = inputName.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < sections.Length; i++)
{
sections[i] = ParserHelpers.SanitizeClassName(sections[i]);
}
return(String.Join(".", sections));
}
public static string RunTemplate(Type templateType, object model)
{
if (_razorService == null)
{
throw new RFSystemException(typeof(RFRazor), "Razor templates not initialized.");
}
lock (_sync)
{
var templateName = ParserHelpers.SanitizeClassName(templateType.FullName).ToLowerInvariant();
return(_razorService.Run(templateName, null, model));
}
}
public string CompileTemplate(RazorLightHost host, ITemplateSource templateSource)
{
string className = ParserHelpers.SanitizeClassName(templateSource.TemplateKey);
var templateEngine = new RazorTemplateEngine(host);
using (var content = templateSource.CreateReader())
{
GeneratorResults result = templateEngine.GenerateCode(content, className, host.DefaultNamespace,
templateSource.FilePath);
if (!result.Success)
{
throw new TemplateParsingException("Failed to parse razor page. See ParserErrors for more details", result.ParserErrors);
}
return(result.GeneratedCode);
}
}
// TODO: This needs to be cached (#1016)
private CodeTree ParseViewFile(RazorTemplateEngine engine,
IFileInfo fileInfo)
{
using (var stream = fileInfo.CreateReadStream())
{
using (var streamReader = new StreamReader(stream))
{
var parseResults = engine.ParseTemplate(streamReader);
var className = ParserHelpers.SanitizeClassName(fileInfo.Name);
var language = engine.Host.CodeLanguage;
var codeGenerator = language.CreateCodeGenerator(className,
engine.Host.DefaultNamespace,
fileInfo.PhysicalPath,
engine.Host);
codeGenerator.Visit(parseResults);
return(codeGenerator.Context.CodeTreeBuilder.CodeTree);
}
}
}
public override void Initialize(RazorHost razorHost, IDictionary <string, string> directives)
{
var fileName = Path.GetFileNameWithoutExtension(razorHost.ProjectRelativePath);
var className = ParserHelpers.SanitizeClassName(fileName);
if (_trimLeadingUnderscores)
{
className = className.TrimStart('_');
}
razorHost.DefaultClassName = className;
// When generating pretty type names, if we also have ItemNamespace from VS, use it.
string vsNamespace;
if (directives.TryGetValue(VsNamespaceKey, out vsNamespace) &&
!string.IsNullOrEmpty(vsNamespace))
{
razorHost.DefaultNamespace = vsNamespace;
}
}
private Type getViewType(RazorTemplate descriptor)
{
var className = ParserHelpers.SanitizeClassName(descriptor.ViewPath);
var baseTemplateType = _razorEngineSettings.BaseTemplateType;
var generatedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo", "WriteLiteralTo",
"FubuMVC.Razor.Rendering.TemplateHelper", "DefineSection");
var codeLanguage = RazorCodeLanguageFactory.Create(descriptor.FilePath.FileExtension());
var host = new RazorEngineHost(codeLanguage)
{
DefaultBaseClass = baseTemplateType.FullName,
DefaultNamespace = "FubuMVC.Razor.GeneratedTemplates",
GeneratedClassContext = generatedClassContext
};
host.NamespaceImports.UnionWith(_commonViewNamespaces.Namespaces);
var results = _templateGenerator.GenerateCode(descriptor, className, host);
return(_templateCompiler.Compile(className, results.GeneratedCode, host));
}
protected virtual string GetClassName()
{
return(ParserHelpers.SanitizeClassName(_baseRelativePath));
}
private string GetClassName()
{
return(ParserHelpers.SanitizeClassName(Path.GetFileName(VirtualPath)));
}
protected override string GetClassName(string virtualPath)
{
return(ParserHelpers.SanitizeClassName(Path.GetFileNameWithoutExtension(virtualPath)));
}
public PrecompiledTemplateKey(string name, ResolveType resolveType) : base(ParserHelpers.SanitizeClassName(name).ToLowerInvariant(), resolveType, null)
{
}
protected virtual string GetClassName()
{
string filename = Path.GetFileNameWithoutExtension(_baseRelativePath);
return(ParserHelpers.SanitizeClassName(filename));
}
protected virtual string GetClassName()
{
string filename = Path.GetFileNameWithoutExtension(this.File.VirtualPath);
return("__" + ParserHelpers.SanitizeClassName(filename));
}
private static string GetClassName(string fileName)
{
return(ParserHelpers.SanitizeClassName(fileName));
}
