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()) { }