protected TemplateCompilationParameters(RazorCodeLanguage language, CodeDomProvider codeProvider, CompilerParameters compilerParameters = null)
{
Language = language;
CodeProvider = codeProvider;
CompilerParameters = compilerParameters ?? new CompilerParameters { GenerateInMemory = true };
AddAssemblyReference(typeof(TemplateBase));
}
/// <summary>
/// Initialises a new instance of <see cref="CompilerServiceBase"/>
/// </summary>
/// <param name="codeLanguage">The code language.</param>
/// <param name="markupParserFactory">The markup parser factory.</param>
protected CompilerServiceBase(RazorCodeLanguage codeLanguage, Func<MarkupParser> markupParserFactory)
{
Contract.Requires(codeLanguage != null);
CodeLanguage = codeLanguage;
MarkupParserFactory = markupParserFactory ?? (() => new HtmlMarkupParser());
}
internal static void WriteGeneratedCode(string sourceFile, CodeCompileUnit codeCompileUnit)
{
if (!OutputDebuggingEnabled)
{
return;
}
RunTask(() =>
{
string extension = Path.GetExtension(sourceFile);
RazorCodeLanguage language = RazorCodeLanguage.GetLanguageByExtension(extension);
CodeDomProvider provider = CodeDomProvider.CreateProvider(language.LanguageName);
using (var writer = new StringWriter())
{
// Trim the html part of cshtml
string outputExtension = extension.Substring(0, 3);
string outputFileName = Normalize(sourceFile) + "_generated" + outputExtension;
string outputPath = Path.Combine(Path.GetDirectoryName(sourceFile), outputFileName);
// REVIEW: Do these options need to be tweaked?
provider.GenerateCodeFromCompileUnit(codeCompileUnit, writer, new CodeGeneratorOptions());
File.WriteAllText(outputPath, writer.ToString());
}
});
}
/// <summary>
/// Gets the RazorCodeLanguage registered for the specified file extension
/// </summary>
/// <param name="fileExtension">The extension, with or without a "."</param>
/// <returns>The language registered for that extension</returns>
public static RazorCodeLanguage GetLanguageByExtension(string fileExtension)
{
RazorCodeLanguage service = null;
Languages.TryGetValue(fileExtension.TrimStart('.'), out service);
return(service);
}
public OpenRastaRazorHost(RazorCodeLanguage codeLanguage)
{
NamespaceImports.Add("System");
NamespaceImports.Add("System.Collections.Generic");
NamespaceImports.Add("System.IO");
NamespaceImports.Add("System.Linq");
NamespaceImports.Add("System.Net");
NamespaceImports.Add("System.Web");
//NamespaceImports.Add("System.Web.Helpers");
NamespaceImports.Add("System.Web.Security");
NamespaceImports.Add("System.Web.UI");
NamespaceImports.Add("System.Web.WebPages");
DefaultNamespace = WebDefaultNamespace;
GeneratedClassContext = new GeneratedClassContext(GeneratedClassContext.DefaultExecuteMethodName,
GeneratedClassContext.DefaultWriteMethodName,
GeneratedClassContext.DefaultWriteLiteralMethodName,
WriteToMethodName,
WriteLiteralToMethodName,
TemplateTypeName,
DefineSectionMethodName);
DefaultBaseClass = typeof (RazorViewBase<>).AssemblyQualifiedName;
DefaultDebugCompilation = true;
CodeLanguage = codeLanguage;
}
/// <summary>
/// Initialises a new instance of <see cref="DirectCompilerServiceBase"/>.
/// </summary>
/// <param name="codeLanguage">The razor code language.</param>
/// <param name="codeDomProvider">The code dom provider used to generate code.</param>
/// <param name="markupParser">The markup parser.</param>
protected DirectCompilerServiceBase(RazorCodeLanguage codeLanguage, CodeDomProvider codeDomProvider, MarkupParser markupParser)
: base(codeLanguage, markupParser)
{
if (codeDomProvider == null)
throw new ArgumentNullException("codeDomProvider");
CodeDomProvider = codeDomProvider;
}
protected TemplateCompilationParameters(RazorCodeLanguage language, CodeDomProvider codeProvider, CompilerParameters compilerParameters = null)
{
Language = language;
CodeProvider = codeProvider;
CompilerParameters = compilerParameters ?? new CompilerParameters { GenerateInMemory = true };
CompilerParameters.ReferencedAssemblies.Add(AppDomain.CurrentDomain
.GetAssemblies().First(asm => asm.FullName.StartsWith("RazorPad.Web")).Location);
}
public SimpleRazorBuildProvider()
{
this._codeLanguage = new CSharpRazorCodeLanguage();
this._compilerType = GetDefaultCompilerTypeForLanguage(this._codeLanguage.LanguageName);
this._host = new SimpleRazorEngineHost(this._codeLanguage);
this._virtualPathDependencies = null;
this._typeName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", this._host.DefaultNamespace, "Foot");
}
/// <summary>
/// Initialises a new instance of <see cref="CompilerServiceBase"/>
/// </summary>
/// <param name="codeLanguage">The code language.</param>
/// <param name="markupParser">The markup parser.</param>
protected CompilerServiceBase(RazorCodeLanguage codeLanguage, MarkupParser markupParser)
{
if (codeLanguage == null)
throw new ArgumentNullException("codeLanguage");
CodeLanguage = codeLanguage;
MarkupParser = markupParser ?? new HtmlMarkupParser();
}
/// <summary>
/// Initializes a new instance of the <see cref="NancyRazorEngineHost"/> class.
/// </summary>
/// <param name="language">The language.</param>
public NancyRazorEngineHost(RazorCodeLanguage language)
: base(language)
{
this.DefaultBaseClass = typeof(NancyRazorViewBase).FullName;
this.DefaultNamespace = "RazorOutput";
this.DefaultClassName = "RazorView";
this.GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral", null, null, null, "DefineSection");
}
public RazorPadHost(RazorCodeLanguage language = null)
{
// ReSharper disable DoNotCallOverridableMethodsInConstructor
DefaultBaseClass = typeof (TemplateBase).FullName;
DefaultClassName = "CompiledTemplate";
DefaultNamespace = "RazorPad.Runtime";
CodeLanguage = language;
// ReSharper restore DoNotCallOverridableMethodsInConstructor
}
public NodeRazorHost(RazorCodeLanguage codeLanguage)
: base(codeLanguage)
{
//Override the default methods to use inside the template
_generatedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo", "WriteLiteralTo", typeof(HelperResult).FullName, "DefineSection")
{
ResolveUrlMethodName = "ResolveUrl",
};
}
public RazorPadMvcEngineHost(RazorCodeLanguage language = null)
: base("~/WebPage.cshtml", null)
{
// ReSharper disable DoNotCallOverridableMethodsInConstructor
DefaultClassName = "WebPage";
DefaultNamespace = "RazorPad";
CodeLanguage = language ?? CodeLanguage;
// ReSharper restore DoNotCallOverridableMethodsInConstructor
}
/// <summary>
/// Initializes a new instance of the <see cref="RazorizerEngineHost" /> class.
/// </summary>
/// <param name="language">The language.</param>
/// <param name="markupParserFactory">The markup parser factory.</param>
/// <param name="decorateCodeGenerator">The decorate code generator.</param>
/// <param name="decorateCodeParser">The code parser factory.</param>
/// <exception cref="System.ArgumentNullException">codeParser</exception>
public RazorizerEngineHost(RazorCodeLanguage language, Func<ParserBase> markupParserFactory,
Func<RazorCodeGenerator, RazorCodeGenerator> decorateCodeGenerator,
Func<ParserBase, ParserBase> decorateCodeParser)
: base(language, markupParserFactory)
{
if (decorateCodeGenerator == null) throw new ArgumentNullException("decorateCodeGenerator");
if (decorateCodeParser == null) throw new ArgumentNullException("decorateCodeParser");
this.decorateCodeGenerator = decorateCodeGenerator;
this.decorateCodeParser = decorateCodeParser;
}
public SimpleRazorEngineHost(RazorCodeLanguage codeLanguage) : base(codeLanguage)
{
base.DefaultBaseClass = SimpleRazorConfiguration.BaseClass;
base.DefaultClassName = SimpleRazorConfiguration.ClassName;
base.DefaultNamespace = SimpleRazorConfiguration.Namespace;
foreach (var namespaceAssembly in SimpleRazorConfiguration.NamespaceImports)
{
base.NamespaceImports.Add(namespaceAssembly.Key);
}
}
/////////////////////////////////////////////////////////////////////////////
private static RazorTemplateEngine CreateHost( RazorCodeLanguage codeLanguage,
string defBaseClassName,
string defNamespace,
string defClassName,
IList<string> refNamespaces,
Action<RazorEngineHost,Action<RazorEngineHost>> createHostHandler
)
{
// ******
RazorEngineHost host = new RazorEngineHost( codeLanguage );
// ******
if( string.IsNullOrEmpty(defBaseClassName) ) {
//defBaseClassName = GetBaseClassName();
throw new ArgumentNullException( "defBaseClassName" );
}
if( string.IsNullOrEmpty(defNamespace) ) {
defNamespace = GetSafeCodeNamespace();
}
if( string.IsNullOrEmpty(defClassName) ) {
defClassName = GetSafeClassName();
}
// ******
host.DefaultBaseClass = defBaseClassName;
host.DefaultClassName = defClassName;
host.DefaultNamespace = defNamespace;
// ******
host.NamespaceImports.Add( "NmpBase.Razor" );
if( null != refNamespaces ) {
foreach( var ns in refNamespaces ) {
host.NamespaceImports.Add( ns );
}
}
// ******
if( null != createHostHandler ) {
//
// presumably user has replaced the base class,
// we are passing the host and the default CreateHostHandler()
//
createHostHandler( host, CreateHostHandler );
}
else {
CreateHostHandler( host );
}
// ******
return new RazorTemplateEngine( host );
}
/// <summary>
/// Initializes a new instance of the <see cref="NancyRazorEngineHost"/> class.
/// </summary>
/// <param name="language">The language.</param>
public NancyRazorEngineHost(RazorCodeLanguage language)
: base(language)
{
this.DefaultBaseClass = typeof(NancyRazorViewBase).FullName;
this.DefaultNamespace = "RazorOutput";
this.DefaultClassName = "RazorView";
var context = new GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo", "WriteLiteralTo", typeof(HelperResult).FullName, "DefineSection");
context.ResolveUrlMethodName = "ResolveUrl";
this.GeneratedClassContext = context;
}
public RazorPadHost(RazorCodeLanguage language = null)
{
// ReSharper disable DoNotCallOverridableMethodsInConstructor
DefaultBaseClass = typeof(TemplateBase).FullName;
DefaultClassName = "CompiledTemplate";
DefaultNamespace = "RazorPad.Runtime";
CodeLanguage = language;
GeneratedClassContext = new GeneratedClassContext(
GeneratedClassContext.DefaultExecuteMethodName,
GeneratedClassContext.DefaultWriteMethodName,
GeneratedClassContext.DefaultWriteLiteralMethodName,
"WriteTo", "WriteLiteralTo",
typeof(HelperResult).FullName);
// ReSharper restore DoNotCallOverridableMethodsInConstructor
}
public RazorEngineHost(RazorCodeLanguage codeLanguage, Func <ParserBase> markupParserFactory)
: this()
{
if (codeLanguage == null)
{
throw new ArgumentNullException("codeLanguage");
}
if (markupParserFactory == null)
{
throw new ArgumentNullException("markupParserFactory");
}
CodeLanguage = codeLanguage;
_markupParserFactory = markupParserFactory;
}
public RazorEngineHost(RazorCodeLanguage codeLanguage, Func<ParserBase> markupParserFactory)
: this()
{
if (codeLanguage == null)
{
throw new ArgumentNullException("codeLanguage");
}
if (markupParserFactory == null)
{
throw new ArgumentNullException("markupParserFactory");
}
CodeLanguage = codeLanguage;
_markupParserFactory = markupParserFactory;
}
public SimpleRazorEngineHost(RazorCodeLanguage codeLanguage) : base(codeLanguage)
{
this.DefaultBaseClass = SimpleRazorConfiguration.BaseClass;
this.DefaultClassName = SimpleRazorConfiguration.ClassPrefix;
this.DefaultNamespace = SimpleRazorConfiguration.Namespace;
base.GeneratedClassContext = new GeneratedClassContext(
executeMethodName: "Execute",
writeMethodName: "Write",
writeLiteralMethodName: "WriteLiteral",
writeToMethodName: "WriteTo",
writeLiteralToMethodName: "WriteLiteralTo",
templateTypeName: null,
defineSectionMethodName: "DefineSection");
foreach (var namespaceAssembly in SimpleRazorConfiguration.NamespaceImports)
{
this.NamespaceImports.Add(namespaceAssembly.Key);
}
}
public RazorMachine(
Type baseType = null,
string rootOperatorPath = null,
RazorCodeLanguage language = null,
string defaultExtension = null,
string autoIncludeNameWithoutExtension = null,
string sharedLocation = null,
bool? includeGeneratedSourceCode = null,
bool? htmlEncode = null,
IEnumerable<string> references = null,
IEnumerable<string> namespaces = null,
IEnumerable<Func<IContentProvider>> contentProviders = null,
bool replaceReferences = false,
bool replaceNamespaces = false,
bool replaceContentProviders = false
)
{
Context = new RazorContext(new RazorConfig()
.Initializer
.TryInitializeFromConfig()
.InitializeByValues(
baseType,
rootOperatorPath,
language,
defaultExtension,
autoIncludeNameWithoutExtension,
sharedLocation,
includeGeneratedSourceCode,
htmlEncode,
references,
namespaces,
contentProviders,
replaceReferences,
replaceNamespaces,
replaceContentProviders
)
.AsReadOnly()
);
}
public SimpleRazorEngineHost(RazorCodeLanguage codeLanguage) : base(codeLanguage)
{
}
protected virtual CodeDomProvider GetCodeProvider(RazorCodeLanguage language)
{
if (language is VBRazorCodeLanguage)
return new VBCodeProvider();
else
return new CSharpCodeProvider();
}
private CompilerResults CompileGeneratedCode(RazorCodeLanguage language, IEnumerable<CodeCompileUnit> codeCompileUnits)
{
Log.Debug("Compiling generated code for {0}", language.GetType().Name);
CodeDomProvider codeProvider = GetCodeProvider(language);
var compilerParameters = new CompilerParameters();
if (compilerParameters.GenerateInMemory)
{
Log.Debug("Generating assemblies in memory");
}
else
{
Log.Debug("Output assembly: {0}", compilerParameters.OutputAssembly);
}
var compilerResults =
codeProvider.CompileAssemblyFromDom(compilerParameters, codeCompileUnits.ToArray());
return compilerResults;
}
IRazorConfigInitializer IRazorConfigInitializer.InitializeByValues(
Type baseType,
string rootOperatorPath,
RazorCodeLanguage language,
string defaultExtension,
string autoIncludeNameWithoutExtension,
string sharedLocation,
bool? includeGeneratedSourceCode,
bool? htmlEncode,
IEnumerable<string> references,
IEnumerable<string> namespaces,
IEnumerable<Func<IContentProvider>> contentProviders,
bool replaceReferences,
bool replaceNamespaces,
bool replaceContentProviders
)
{
EnsureNotReadonly();
RootOperator.Path = rootOperatorPath ?? RootOperator.Path;
Templates.BaseType = baseType ?? Templates.BaseType;
Templates.Language = language ?? Templates.Language;
Templates.DefaultExtension = (defaultExtension ?? Templates.DefaultExtension).EmptyAsNull();
Templates.AutoIncludeName = (autoIncludeNameWithoutExtension ?? Templates.AutoIncludeName).EmptyAsNull();
Templates.SharedLocation = (sharedLocation ?? Templates.SharedLocation).EmptyAsNull();
if (includeGeneratedSourceCode != null)
Templates.IncludeGeneratedSourceCode = includeGeneratedSourceCode.Value;
if (htmlEncode != null)
Templates.HtmlEncode = htmlEncode.Value;
if (references != null) {
References = replaceReferences ? references.ToList().AsReadOnly() : References.Union(references, StringComparer.InvariantCultureIgnoreCase).ToList().AsReadOnly();
}
if (namespaces != null) {
Namespaces = replaceNamespaces ? namespaces.ToList().AsReadOnly() : Namespaces.Union(namespaces).ToList().AsReadOnly();
}
if (contentProviders != null) {
ContentProviders = replaceContentProviders ? contentProviders.ToList().AsReadOnly() : ContentProviders.Union(contentProviders).ToList().AsReadOnly();
}
return this;
}
public MvcWebPageRazorHost(RazorCodeLanguage codeLanguage, Func<MarkupParser> markupParserFactory)
: base(codeLanguage, markupParserFactory)
{
Init();
}
public MvcWebPageRazorHost(RazorCodeLanguage codeLanguage)
: base(codeLanguage)
{
Init();
}
public RazorHtmlSpans(string html, string fileExtension)
{
codeLanguage = RazorCodeLanguage.GetLanguageByExtension(fileExtension);
ReadHtmlSpans(html);
}
public static OpenRastaRazorHost CreateHost(RazorCodeLanguage codeLanguage)
{
return new OpenRastaRazorHost(codeLanguage);
}
/// <summary>
/// Initialises a new instance of <see cref="DirectCompilerServiceBase"/>.
/// </summary>
/// <param name="codeLanguage">The razor code language.</param>
/// <param name="codeDomProvider">The code dom provider used to generate code.</param>
/// <param name="markupParserFactory">The markup parser factory.</param>
protected DirectCompilerServiceBase(RazorCodeLanguage codeLanguage, CodeDomProvider codeDomProvider, Func<MarkupParser> markupParserFactory)
: base(codeLanguage, markupParserFactory)
{
_codeDomProvider = codeDomProvider;
}
/// <summary>
/// Initialises a new instance of <see cref="RazorEngineHost"/>.
/// </summary>
/// <param name="language">The code language.</param>
/// <param name="markupParserFactory">The markup parser factory delegate.</param>
public RazorEngineHost(RazorCodeLanguage language, Func<ParserBase> markupParserFactory)
: base(language, markupParserFactory) { }
/// <summary>
/// Creates a host which uses the specified code language and the HTML markup language
/// </summary>
/// <param name="codeLanguage">The code language to use</param>
public RazorEngineHost(RazorCodeLanguage codeLanguage)
: this(codeLanguage, () => new HtmlMarkupParser())
{
}
public RazorEngineHost(RazorCodeLanguage codeLanguage)
: this(codeLanguage, () => new HtmlMarkupParser()) {
}
