public TemplateFileGenerator(ITemplateResolver resolver, ITemplateRepository repository, IFileSystem fileSystem, ExecutionContext executionContext) { this.resolver = resolver; this.repository = repository; this.fileSystem = fileSystem; this.executionContext = executionContext; }
public static ICloudFormationRequestBuilder Create(ITemplateResolver templateResolver, string templateFile, string templateParameterFile, bool filesInPackage, ICalamariFileSystem fileSystem, IVariables variables, string stackName, List <string> capabilities, bool disableRollback, string roleArn, IEnumerable <KeyValuePair <string, string> > tags, StackArn stack, Func <IAmazonCloudFormation> clientFactory) { var resolvedTemplate = templateResolver.Resolve(templateFile, filesInPackage, variables); var resolvedParameters = templateResolver.MaybeResolve(templateParameterFile, filesInPackage, variables); if (!string.IsNullOrWhiteSpace(templateParameterFile) && !resolvedParameters.Some()) { throw new CommandException("Could not find template parameters file: " + templateParameterFile); } return(new CloudFormationTemplate(() => variables.Evaluate(fileSystem.ReadFile(resolvedTemplate.Value)), CloudFormationParametersFile.Create(resolvedParameters, fileSystem, variables), stackName, capabilities, disableRollback, roleArn, tags, stack, clientFactory, variables)); }
public MailBodyBuilder(ITemplateCompiler compiler, ITemplateProvider provider, ITemplateResolver resolver) : this() { _compiler = compiler; _provider = provider; _resolver = resolver; }
public AssembleCommandHandler(IProjectContextFactory projectContextFactory, ITemplateResolver templateResolver, ITemplateInvoker templateInvoker, ISolutionPathResolver solutionPathResolver) { _projectContextFactory = projectContextFactory; _templateResolver = templateResolver; _templateInvoker = templateInvoker; _solutionPathResolver = solutionPathResolver; }
/// <summary> /// Sets the resolver used to locate unknown templates. /// </summary> /// <param name="resolver">The resolver instance to use.</param> /// <returns>The current configuration builder.</returns> public IConfigurationBuilder ResolveUsing(ITemplateResolver resolver) { //Contract.Requires(resolver != null); _config.Resolver = resolver; return(this); }
public DeployService(IFileSystem fileSystem, ITemplateResolver resolver, ITargetParser targetParser, ExecutionContext executionContext) { this.fileSystem = fileSystem; this.resolver = resolver; this.targetParser = targetParser; this.executionContext = executionContext; }
public CommandDefinitionContentProvider(IFileSystem fileSystem, ITemplateResolver templateResolver, ITemplateRepository templateRepository, ICodeLanguage codeLanguage) { this.fileSystem = fileSystem; this.templateResolver = templateResolver; this.templateRepository = templateRepository; this.codeLanguage = codeLanguage; }
/// <summary> /// /// </summary> /// <param name="mailAttributes"></param> /// <param name="mailSender"></param> /// <param name="templateResolver"></param> protected HBSMailerBase(MailAttributes mailAttributes = null, IMailSender mailSender = null, ITemplateResolver templateResolver = null, ITemplateService templateService = null) { MailAttributes = mailAttributes ?? new MailAttributes(); MailSender = mailSender ?? new SmtpMailSender(); _templateResolver = templateResolver; ViewBag = new ExpandoObject(); _templateService = templateService; }
public void Resolve(ITemplateResolver resolver) { resolved = resolver.Resolve(link); if (resolved == null) { throw new Exception(string.Format("Could not resolve {0} link", link)); } }
public RazorViewParser(ITemplateResolver resolver) { if (resolver == null) throw new ArgumentNullException("resolver"); var config = new TemplateServiceConfiguration { Resolver = resolver }; _templateService = new TemplateService(config); }
/// <summary> /// Adds a resolver used to resolve named template content. /// </summary> /// <param name="resolver">The resolver to add.</param> public void AddResolver(ITemplateResolver resolver) { if (resolver == null) { throw new ArgumentNullException("resolver"); } templateResolvers.Add(resolver); }
public CppContentProvider(IFileSystem fileSystem, ITemplateResolver resolver) { this.fileSystem = fileSystem; this.resolver = resolver; string pathSeparator = Regex.Escape(new string(Path.DirectorySeparatorChar, 1)); relativeDirectoryRegex = new Regex(@"[^" + pathSeparator + @"]+(?:[" + pathSeparator + @"](?<split>.*))?", RegexOptions.Compiled); }
/// <summary> /// Sets the template resolver. /// </summary> /// <param name="templateResolverType">The template resolver type.</param> private void SetTemplateResolver(string templateResolverType) { var type = GetType(templateResolverType); if (type != null) { Resolver = GetInstance <ITemplateResolver>(type); } }
public InitCommandHandler(ITemplateResolver templateResolver, IProjectContextFactory projectContextFactory, ITemplateInvoker templateInvoker, AssembleCommandHandler assembleCommandHandler) { _templateResolver = templateResolver; _projectContextFactory = projectContextFactory; _templateInvoker = templateInvoker; _assembleCommandHandler = assembleCommandHandler; }
public RazorConfiguration(ITemplateResolver templateResolver) { BaseTemplateType = typeof(RazorTemplate <>); EncodedStringFactory = new RawStringFactory(); Namespaces = new HashSet <string> { "System", "RazorEngine" }; Resolver = templateResolver; }
private void AddValidTemplate(Assembly assembly,ICollection<Template> templates, ITemplateModel modelInstance) { _resolver = new EmbeddedTemplateResolver(assembly); Template template = new Template(); template.Name = _nameFormatter.GetName(modelInstance); template.Text = _resolver.GetTemplate(template.Name); template.Model = modelInstance; if (!String.IsNullOrEmpty(template.Text)) { templates.Add(template); } }
public RazorViewParser(ITemplateResolver resolver) { if (resolver == null) { throw new ArgumentNullException("resolver"); } var config = new TemplateServiceConfiguration { Resolver = resolver }; _templateService = new TemplateService(config); }
public static void Defaults(ITemplateResolver templateResolver) { var buildTemplate = B.AutoMock <Template>().Subject; buildTemplate.Name = "Psake"; buildTemplate.TemplateType = TemplateType.Build; var sourceTemplate = B.AutoMock <Template>().Subject; sourceTemplate.Name = "VisualStudio"; sourceTemplate.TemplateType = TemplateType.Source; templateResolver.Templates = new[] { buildTemplate, sourceTemplate }; }
public RazorMailer(string baseDir = null) { baseDir = baseDir ?? GetDefaultBaseDir(); var defaultResolver = new DefaultResolver(baseDir); this.templateResolver = defaultResolver; this.emailResolver = defaultResolver; this.templateService = new TemplateService(new EmailTemplateConfiguration(baseDir) { Resolver = defaultResolver }); Razor.SetTemplateService(templateService); }
public void Resolve(ITemplateResolver resolver) { inherited = new ITemplateSet[inheritedNotResolved.Length]; for (int i = 0; i < inheritedNotResolved.Length; i++) { inherited[i] = resolver.Resolve(inheritedNotResolved[i]); } foreach (object obj in templates.Values) { if (obj is ITemplateSet) { (obj as ITemplateSet).Resolve(resolver); } } }
/// <summary> /// /// </summary> /// <param name="templateResolver"></param> /// <param name="viewSettings"></param> public TemplateService(ITemplateResolver templateResolver, ViewSettings viewSettings) { _templateResolver = templateResolver; _hbsService = Handlebars.Create(); RegisterHelpers(viewSettings); _templateResolver.GetAllPartialTemplates().ForEach(template => { try { _hbsService.RegisterTemplate(template.Key, template.Value); } catch (System.Exception ex) { throw new System.Exception($"Error at template key = {template.Key}", ex); } }); }
/// <summary> /// Initializes a new instance of the <see cref="TemplateManager"/> class. /// </summary> /// <param name="templateResolver">The template resolver.</param> /// <param name="stackOperation">Stack operation being performed</param> /// <param name="logger">Logger to send error messages to.</param> public TemplateManager(ITemplateResolver templateResolver, StackOperation stackOperation, ILogger logger) { this.templateResolver = templateResolver; this.logger = logger; this.stackOperation = stackOperation; try { this.TemplateParameters = TemplateParser.Create(templateResolver.FileContent).GetParameters().ToList(); } catch (Exception e) { this.logger?.LogError($"Error parsing CloudFormation Template: {e.Message}"); this.logger?.LogError(e.StackTrace); throw; } }
public RazorMailer(ITemplateServiceConfiguration config, IEmailResolver emailResolver) { if (config == null) { throw new ArgumentNullException("config"); } if (config.Resolver == null) { throw new ArgumentException("Custom configuration must specify a resolver"); } if (emailResolver == null) { throw new ArgumentNullException("emailResolver"); } this.emailResolver = emailResolver; this.templateResolver = config.Resolver; this.templateService = new TemplateService(config); }
public static IAppBuilder UseRazor(this IAppBuilder appBuilder, Action<IRouteTable> initRoutes, IFileSystem fileSystem = null, ITemplateResolver templateResolver = null) { if (appBuilder == null) { throw new ArgumentNullException("appBuilder"); } if (initRoutes == null) { throw new ArgumentNullException("initRoutes"); } var routes = new RouteTable(fileSystem ?? new PhysicalFileSystem("")); initRoutes(routes); var renderer = new RazorRenderer(); var config = new TemplateServiceConfiguration { Resolver = templateResolver ?? new FileSystemTempleteResolver(fileSystem ?? new PhysicalFileSystem("")) }; var templateService = new TemplateService(config); RazorEngine.Razor.SetTemplateService(templateService); var middleware = new RazorMiddleware(routes, renderer); return appBuilder.UseHandlerAsync(middleware.Handle); }
/// <summary> /// Initialises a new instance of <see cref="DelegateTemplateResolver"/>. /// </summary> /// <param name="resolver">The resolver delegate.</param> public WrapperTemplateManager(ITemplateResolver resolver) { Contract.Requires(resolver != null); _resolver = resolver; }
public IMailBodyBuilder UseResolver(ITemplateResolver resolver) => Use(() => _resolver = resolver);
/// <summary> /// Adds a resolver used to resolve named template content. /// </summary> /// <param name="resolver">The resolver to add.</param> public static void AddResolver(ITemplateResolver resolver) { DefaultTemplateService.AddResolver(resolver); }
public TemplateFileGenerator(ITemplateResolver resolver, ITemplateRepository repository, IFileSystem fileSystem) { this.resolver = resolver; this.repository = repository; this.fileSystem = fileSystem; }
public TemplateService(ICalamariFileSystem fileSystem, ITemplateResolver resolver, ITemplateReplacement replacement) { this.fileSystem = fileSystem; this.resolver = resolver; this.replacement = replacement; }
public TemplateService(ICalamariFileSystem fileSystem, ITemplateResolver resolver) { this.fileSystem = fileSystem; this.resolver = resolver; }
/// <summary> /// Create a new readonly view (and copy) of the given configuration. /// </summary> /// <param name="config">the configuration to copy.</param> public ReadOnlyTemplateServiceConfiguration(ITemplateServiceConfiguration config) { if (config == null) { throw new ArgumentNullException("config"); } _allowMissingPropertiesOnDynamic = config.AllowMissingPropertiesOnDynamic; _activator = config.Activator; if (_activator == null) { throw new ArgumentNullException("config", "the configured Activator cannot be null!"); } _baseTemplateType = config.BaseTemplateType; // Check if the baseTemplateType is valid. if (_baseTemplateType != null && (!typeof(ITemplate).IsAssignableFrom(_baseTemplateType) || typeof(ITemplate) == _baseTemplateType)) { throw new ArgumentOutOfRangeException("config", "the configured BaseTemplateType must implement ITemplate!"); } _cachingProvider = config.CachingProvider; if (_cachingProvider == null) { throw new ArgumentNullException("config", "the configured CachingProvider cannot be null!"); } #if !RAZOR4 #pragma warning disable 0618 // Backwards Compat. _codeInspectors = config.CodeInspectors; if (_codeInspectors == null) { throw new ArgumentNullException("config", "the configured CodeInspectos cannot be null!"); } _codeInspectors = new List <ICodeInspector>(_codeInspectors); #pragma warning restore 0618 // Backwards Compat. #endif _compilerServiceFactory = config.CompilerServiceFactory; if (_compilerServiceFactory == null) { throw new ArgumentNullException("config", "the configured CompilerServiceFactory cannot be null!"); } _debug = config.Debug; _disableTempFileLocking = config.DisableTempFileLocking; _encodedStringFactory = config.EncodedStringFactory; if (_encodedStringFactory == null) { throw new ArgumentNullException("config", "the configured EncodedStringFactory cannot be null!"); } _language = config.Language; _namespaces = config.Namespaces; if (_namespaces == null) { throw new ArgumentNullException("config", "the configured Namespaces cannot be null!"); } _namespaces = new HashSet <string>(_namespaces); _referenceResolver = config.ReferenceResolver; if (_referenceResolver == null) { throw new ArgumentNullException("config", "the configured ReferenceResolver cannot be null!"); } _templateManager = config.TemplateManager; #if NO_CONFIGURATION if (_templateManager == null) { throw new ArgumentNullException("config", "the configured TemplateManager cannot be null!"); } #else #pragma warning disable 0618 // Backwards Compat. _resolver = config.Resolver; if (_templateManager == null) { if (_resolver != null) { _templateManager = new Xml.WrapperTemplateManager(_resolver); } else { throw new ArgumentNullException("config", "the configured TemplateManager and Resolver cannot be null!"); } } #pragma warning restore 0618 // Backwards Compat. #endif ConfigureCompilerBuilder = config.ConfigureCompilerBuilder; }
/// <summary> /// Initializes a new <see cref="RazorViewParser"/> with optional arguments. /// </summary> /// <param name="resolver">The <see cref="ITemplateResolver"/>. If not provided, <see cref="TemplateResolver"/> is used.</param> /// <param name="baseTemplateType">The <see cref="Type"/> to use as the TemplateBase.</param> public RazorViewParser(ITemplateResolver resolver = null, Type baseTemplateType = null) : this(new TemplateServiceConfiguration { BaseTemplateType = baseTemplateType, Resolver = resolver ?? new TemplateResolver() }) { }
public RazorMailer(ITemplateResolver templateResolver, IEmailResolver emailResolver) : this(new TemplateServiceConfiguration { Resolver = templateResolver }, emailResolver) { }
/// <summary> /// Create a new readonly view (and copy) of the given configuration. /// </summary> /// <param name="config">the configuration to copy.</param> public ReadOnlyTemplateServiceConfiguration(ITemplateServiceConfiguration config) { if (config == null) { throw new ArgumentNullException("config"); } _allowMissingPropertiesOnDynamic = config.AllowMissingPropertiesOnDynamic; _activator = config.Activator; if (_activator == null) { throw new ArgumentNullException("config", "the configured Activator cannot be null!"); } _baseTemplateType = config.BaseTemplateType; // Check if the baseTemplateType is valid. if (_baseTemplateType != null && (!typeof(ITemplate).IsAssignableFrom(_baseTemplateType) || typeof(ITemplate) == _baseTemplateType)) { throw new ArgumentOutOfRangeException("config", "the configured BaseTemplateType must implement ITemplate!"); } _cachingProvider = config.CachingProvider; if (_cachingProvider == null) { throw new ArgumentNullException("config", "the configured CachingProvider cannot be null!"); } #if !RAZOR4 #pragma warning disable 0618 // Backwards Compat. _codeInspectors = config.CodeInspectors; if (_codeInspectors == null) { throw new ArgumentNullException("config", "the configured CodeInspectos cannot be null!"); } _codeInspectors = new List<ICodeInspector>(_codeInspectors); #pragma warning restore 0618 // Backwards Compat. #endif _compilerServiceFactory = config.CompilerServiceFactory; if (_compilerServiceFactory == null) { throw new ArgumentNullException("config", "the configured CompilerServiceFactory cannot be null!"); } _debug = config.Debug; _disableTempFileLocking = config.DisableTempFileLocking; _encodedStringFactory = config.EncodedStringFactory; if (_encodedStringFactory == null) { throw new ArgumentNullException("config", "the configured EncodedStringFactory cannot be null!"); } _language = config.Language; _namespaces = config.Namespaces; if (_namespaces == null) { throw new ArgumentNullException("config", "the configured Namespaces cannot be null!"); } _namespaces = new HashSet<string>(_namespaces); _referenceResolver = config.ReferenceResolver; if (_referenceResolver == null) { throw new ArgumentNullException("config", "the configured ReferenceResolver cannot be null!"); } #pragma warning disable 0618 // Backwards Compat. _resolver = config.Resolver; _templateManager = config.TemplateManager; if (_templateManager == null) { if (_resolver != null) { _templateManager = new Xml.WrapperTemplateManager(_resolver); } else { throw new ArgumentNullException("config", "the configured TemplateManager and Resolver cannot be null!"); } } #pragma warning restore 0618 // Backwards Compat. }
public TemplateReplacement(ITemplateResolver resolver) { this.resolver = resolver; }
public TypeContentProvider(ITemplateRepository templateRepository, ITemplateResolver resolver) { this.templateRepository = templateRepository; this.resolver = resolver; }